mm: cma: discard clean pages during contiguous allocation instead of migration

Drop clean cache pages instead of migration during alloc_contig_range() to
minimise allocation latency by reducing the amount of migration that is
necessary.  It's useful for CMA because latency of migration is more
important than evicting the background process's working set.  In
addition, as pages are reclaimed then fewer free pages for migration
targets are required so it avoids memory reclaiming to get free pages,
which is a contributory factor to increased latency.

I measured elapsed time of __alloc_contig_migrate_range() which migrates
10M in 40M movable zone in QEMU machine.

Before - 146ms, After - 7ms

Signed-off-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Mel Gorman <mgorman@suse.de>
Cc: Marek Szyprowski <m.szyprowski@samsung.com>
Acked-by: Michal Nazarewicz <mina86@mina86.com>
Cc: Rik van Riel <riel@redhat.com>
Tested-by: Kyungmin Park <kyungmin.park@samsung.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/internal.h b/mm/internal.h
index bbd7b34db4eab4a8883be1fdeaf6aac026e9f534..8312d4fadf59dd32f21733b66ab14737e64da7b7 100644 (file)
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -356,5 +356,6 @@ extern unsigned long vm_mmap_pgoff(struct file *, unsigned long,
         unsigned long, unsigned long);
 
 extern void set_pageblock_order(void);
-
+unsigned long reclaim_clean_pages_from_list(struct zone *zone,
+                                           struct list_head *page_list);
 #endif /* __MM_INTERNAL_H */

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index a4ff74e67ec23a3826873f47c10213ef61ee3cfe..3cd1b72d96ce5e64552e3359886938d5936aa8a2 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -5699,6 +5699,8 @@ static int __alloc_contig_migrate_range(unsigned long start, unsigned long end)
                        break;
                }
 
+               reclaim_clean_pages_from_list(cc.zone, &cc.migratepages);
+
                ret = migrate_pages(&cc.migratepages,
                                    __alloc_contig_migrate_alloc,
                                    0, false, MIGRATE_SYNC);

diff --git a/mm/vmscan.c b/mm/vmscan.c
index d16bf5a5326614e54cc37cedffc8a697a16b17fa..f8f56f8bc9c799e197ce1a09414b5bf979d55857 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -674,8 +674,10 @@ static enum page_references page_check_references(struct page *page,
 static unsigned long shrink_page_list(struct list_head *page_list,
                                      struct zone *zone,
                                      struct scan_control *sc,
+                                     enum ttu_flags ttu_flags,
                                      unsigned long *ret_nr_dirty,
-                                     unsigned long *ret_nr_writeback)
+                                     unsigned long *ret_nr_writeback,
+                                     bool force_reclaim)
 {
        LIST_HEAD(ret_pages);
        LIST_HEAD(free_pages);
@@ -689,10 +691,10 @@ static unsigned long shrink_page_list(struct list_head *page_list,
 
        mem_cgroup_uncharge_start();
        while (!list_empty(page_list)) {
-               enum page_references references;
                struct address_space *mapping;
                struct page *page;
                int may_enter_fs;
+               enum page_references references = PAGEREF_RECLAIM;
 
                cond_resched();
 
@@ -758,7 +760,9 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                        wait_on_page_writeback(page);
                }
 
-               references = page_check_references(page, sc);
+               if (!force_reclaim)
+                       references = page_check_references(page, sc);
+
                switch (references) {
                case PAGEREF_ACTIVATE:
                        goto activate_locked;
@@ -788,7 +792,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                 * processes. Try to unmap it here.
                 */
                if (page_mapped(page) && mapping) {
-                       switch (try_to_unmap(page, TTU_UNMAP)) {
+                       switch (try_to_unmap(page, ttu_flags)) {
                        case SWAP_FAIL:
                                goto activate_locked;
                        case SWAP_AGAIN:
@@ -960,6 +964,33 @@ keep:
        return nr_reclaimed;
 }
 
+unsigned long reclaim_clean_pages_from_list(struct zone *zone,
+                                           struct list_head *page_list)
+{
+       struct scan_control sc = {
+               .gfp_mask = GFP_KERNEL,
+               .priority = DEF_PRIORITY,
+               .may_unmap = 1,
+       };
+       unsigned long ret, dummy1, dummy2;
+       struct page *page, *next;
+       LIST_HEAD(clean_pages);
+
+       list_for_each_entry_safe(page, next, page_list, lru) {
+               if (page_is_file_cache(page) && !PageDirty(page)) {
+                       ClearPageActive(page);
+                       list_move(&page->lru, &clean_pages);
+               }
+       }
+
+       ret = shrink_page_list(&clean_pages, zone, &sc,
+                               TTU_UNMAP|TTU_IGNORE_ACCESS,
+                               &dummy1, &dummy2, true);
+       list_splice(&clean_pages, page_list);
+       __mod_zone_page_state(zone, NR_ISOLATED_FILE, -ret);
+       return ret;
+}
+
 /*
  * Attempt to remove the specified page from its LRU.  Only take this page
  * if it is of the appropriate PageActive status.  Pages which are being
@@ -1278,8 +1309,8 @@ shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
        if (nr_taken == 0)
                return 0;
 
-       nr_reclaimed = shrink_page_list(&page_list, zone, sc,
-                                               &nr_dirty, &nr_writeback);
+       nr_reclaimed = shrink_page_list(&page_list, zone, sc, TTU_UNMAP,
+                                       &nr_dirty, &nr_writeback, false);
 
        spin_lock_irq(&zone->lru_lock);