page_alloc: consider highatomic reserve in watermark fast

author Jaewon Kim <jaewon31.kim@samsung.com>

Fri, 7 Aug 2020 06:25:20 +0000 (23:25 -0700)

committer Linus Torvalds <torvalds@linux-foundation.org>

Fri, 7 Aug 2020 18:33:28 +0000 (11:33 -0700)
author Jaewon Kim <jaewon31.kim@samsung.com>
Fri, 7 Aug 2020 06:25:20 +0000 (23:25 -0700)
committer Linus Torvalds <torvalds@linux-foundation.org>
Fri, 7 Aug 2020 18:33:28 +0000 (11:33 -0700)
diff --git a/mm/page_alloc.c b/mm/page_alloc.c

index ce2409ee2144b1d0e3452b9b10a8dc60efa1416f..1b2f7b3bba342ee3d4c99d0a7d06a1096461ecd7 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3486,6 +3486,29 @@ static noinline bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
  }
  ALLOW_ERROR_INJECTION(should_fail_alloc_page, TRUE);
  
+static inline long __zone_watermark_unusable_free(struct zone *z,
+                               unsigned int order, unsigned int alloc_flags)
+{
+       const bool alloc_harder = (alloc_flags & (ALLOC_HARDER|ALLOC_OOM));
+       long unusable_free = (1 << order) - 1;
+
+       /*
+        * If the caller does not have rights to ALLOC_HARDER then subtract
+        * the high-atomic reserves. This will over-estimate the size of the
+        * atomic reserve but it avoids a search.
+        */
+       if (likely(!alloc_harder))
+               unusable_free += z->nr_reserved_highatomic;
+
+#ifdef CONFIG_CMA
+       /* If allocation can't use CMA areas don't use free CMA pages */
+       if (!(alloc_flags & ALLOC_CMA))
+               unusable_free += zone_page_state(z, NR_FREE_CMA_PAGES);
+#endif
+
+       return unusable_free;
+}
+
  /*
   * Return true if free base pages are above 'mark'. For high-order checks it
   * will return true of the order-0 watermark is reached and there is at least
@@ -3501,19 +3524,12 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
         const bool alloc_harder = (alloc_flags & (ALLOC_HARDER|ALLOC_OOM));
  
         /* free_pages may go negative - that's OK */
-       free_pages -= (1 << order) - 1;
+       free_pages -= __zone_watermark_unusable_free(z, order, alloc_flags);
  
         if (alloc_flags & ALLOC_HIGH)
                 min -= min / 2;
  
-       /*
-        * If the caller does not have rights to ALLOC_HARDER then subtract
-        * the high-atomic reserves. This will over-estimate the size of the
-        * atomic reserve but it avoids a search.
-        */
-       if (likely(!alloc_harder)) {
-               free_pages -= z->nr_reserved_highatomic;
-       } else {
+       if (unlikely(alloc_harder)) {
                 /*
                  * OOM victims can try even harder than normal ALLOC_HARDER
                  * users on the grounds that it's definitely going to be in
@@ -3526,13 +3542,6 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
                         min -= min / 4;
         }
  
-
-#ifdef CONFIG_CMA
-       /* If allocation can't use CMA areas don't use free CMA pages */
-       if (!(alloc_flags & ALLOC_CMA))
-               free_pages -= zone_page_state(z, NR_FREE_CMA_PAGES);
-#endif
-
         /*
          * Check watermarks for an order-0 allocation request. If these
          * are not met, then a high-order request also cannot go ahead
@@ -3581,25 +3590,22 @@ static inline bool zone_watermark_fast(struct zone *z, unsigned int order,
                                 unsigned long mark, int highest_zoneidx,
                                 unsigned int alloc_flags)
  {
-       long free_pages = zone_page_state(z, NR_FREE_PAGES);
-       long cma_pages = 0;
+       long free_pages;
  
-#ifdef CONFIG_CMA
-       /* If allocation can't use CMA areas don't use free CMA pages */
-       if (!(alloc_flags & ALLOC_CMA))
-               cma_pages = zone_page_state(z, NR_FREE_CMA_PAGES);
-#endif
+       free_pages = zone_page_state(z, NR_FREE_PAGES);
  
         /*
          * Fast check for order-0 only. If this fails then the reserves
-        * need to be calculated. There is a corner case where the check
-        * passes but only the high-order atomic reserve are free. If
-        * the caller is !atomic then it'll uselessly search the free
-        * list. That corner case is then slower but it is harmless.
+        * need to be calculated.
          */
-       if (!order && (free_pages - cma_pages) >
-                               mark + z->lowmem_reserve[highest_zoneidx])
-               return true;
+       if (!order) {
+               long fast_free;
+
+               fast_free = free_pages;
+               fast_free -= __zone_watermark_unusable_free(z, 0, alloc_flags);
+               if (fast_free > mark + z->lowmem_reserve[highest_zoneidx])
+                       return true;
+       }
  
         return __zone_watermark_ok(z, order, mark, highest_zoneidx, alloc_flags,
                                         free_pages);
author	Jaewon Kim <jaewon31.kim@samsung.com>
	Fri, 7 Aug 2020 06:25:20 +0000 (23:25 -0700)
committer	Linus Torvalds <torvalds@linux-foundation.org>
	Fri, 7 Aug 2020 18:33:28 +0000 (11:33 -0700)