mm: thrash detection-based file cache sizing

The VM maintains cached filesystem pages on two types of lists.  One
list holds the pages recently faulted into the cache, the other list
holds pages that have been referenced repeatedly on that first list.
The idea is to prefer reclaiming young pages over those that have shown
to benefit from caching in the past.  We call the recently usedbut
ultimately was not significantly better than a FIFO policy and still
thrashed cache based on eviction speed, rather than actual demand for
cache.

This patch solves one half of the problem by decoupling the ability to
detect working set changes from the inactive list size.  By maintaining
a history of recently evicted file pages it can detect frequently used
pages with an arbitrarily small inactive list size, and subsequently
apply pressure on the active list based on actual demand for cache, not
just overall eviction speed.

Every zone maintains a counter that tracks inactive list aging speed.
When a page is evicted, a snapshot of this counter is stored in the
now-empty page cache radix tree slot.  On refault, the minimum access
distance of the page can be assessed, to evaluate whether the page
should be part of the active list or not.

This fixes the VM's blindness towards working set changes in excess of
the inactive list.  And it's the foundation to further improve the
protection ability and reduce the minimum inactive list size of 50%.

Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Reviewed-by: Rik van Riel <riel@redhat.com>
Reviewed-by: Minchan Kim <minchan@kernel.org>
Reviewed-by: Bob Liu <bob.liu@oracle.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Greg Thelen <gthelen@google.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Jan Kara <jack@suse.cz>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Metin Doslu <metin@citusdata.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: Ozgun Erdogan <ozgun@citusdata.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roman Gushchin <klamm@yandex-team.ru>
Cc: Ryan Mallon <rmallon@gmail.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 44 insertions, 17 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index 05c44aa44188..a603c4d7d3c9 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -469,7 +469,7 @@ int replace_page_cache_page(struct page *old, struct page *new, gfp_t gfp_mask)
 EXPORT_SYMBOL_GPL(replace_page_cache_page);
 
 static int page_cache_tree_insert(struct address_space *mapping,
-                                  struct page *page)
+                                  struct page *page, void **shadowp)
 {
         void **slot;
         int error;
@@ -484,6 +484,8 @@ static int page_cache_tree_insert(struct address_space *mapping,
                 radix_tree_replace_slot(slot, page);
                 mapping->nrshadows--;
                 mapping->nrpages++;
+                if (shadowp)
+                        *shadowp = p;
                 return 0;
         }
         error = radix_tree_insert(&mapping->page_tree, page->index, page);
@@ -492,18 +494,10 @@ static int page_cache_tree_insert(struct address_space *mapping,
         return error;
 }
 
-/**
- * add_to_page_cache_locked - add a locked page to the pagecache
- * @page:       page to add
- * @mapping:    the page's address_space
- * @offset:     page index
- * @gfp_mask:   page allocation mode
- *
- * This function is used to add a page to the pagecache. It must be locked.
- * This function does not add the page to the LRU.  The caller must do that.
- */
-int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
-                pgoff_t offset, gfp_t gfp_mask)
+static int __add_to_page_cache_locked(struct page *page,
+                                      struct address_space *mapping,
+                                      pgoff_t offset, gfp_t gfp_mask,
+                                      void **shadowp)
 {
         int error;
 
@@ -526,7 +520,7 @@ int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
         page->index = offset;
 
         spin_lock_irq(&mapping->tree_lock);
-        error = page_cache_tree_insert(mapping, page);
+        error = page_cache_tree_insert(mapping, page, shadowp);
         radix_tree_preload_end();
         if (unlikely(error))
                 goto err_insert;
@@ -542,16 +536,49 @@ err_insert:
         page_cache_release(page);
         return error;
 }
+
+/**
+ * add_to_page_cache_locked - add a locked page to the pagecache
+ * @page:       page to add
+ * @mapping:    the page's address_space
+ * @offset:     page index
+ * @gfp_mask:   page allocation mode
+ *
+ * This function is used to add a page to the pagecache. It must be locked.
+ * This function does not add the page to the LRU.  The caller must do that.
+ */
+int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
+                pgoff_t offset, gfp_t gfp_mask)
+{
+        return __add_to_page_cache_locked(page, mapping, offset,
+                                          gfp_mask, NULL);
+}
 EXPORT_SYMBOL(add_to_page_cache_locked);
 
 int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
                                 pgoff_t offset, gfp_t gfp_mask)
 {
+        void *shadow = NULL;
         int ret;
 
-        ret = add_to_page_cache(page, mapping, offset, gfp_mask);
-        if (ret == 0)
-                lru_cache_add_file(page);
+        __set_page_locked(page);
+        ret = __add_to_page_cache_locked(page, mapping, offset,
+                                         gfp_mask, &shadow);
+        if (unlikely(ret))
+                __clear_page_locked(page);
+        else {
+                /*
+                 * The page might have been evicted from cache only
+                 * recently, in which case it should be activated like
+                 * any other repeatedly accessed page.
+                 */
+                if (shadow && workingset_refault(shadow)) {
+                        SetPageActive(page);
+                        workingset_activation(page);
+                } else
+                        ClearPageActive(page);
+                lru_cache_add(page);
+        }
         return ret;
 }
 EXPORT_SYMBOL_GPL(add_to_page_cache_lru);