skip swapcache for super fast device

With fast swap storage, platform want to use swap more aggressively and swap-in is crucial to application latency.

The rw_page based synchronous devices like zram, pmem and btt are such fast storage. When I profile swapin performance with zram lz4 decompress test, S/W overhead is more than 70%. Maybe, it would be bigger in nvdimm.

This patch aims for reducing swap-in latency via skipping swapcache if swap device is synchronous device like rw_page based device. It enhances 45% my swapin test(5G sequential swapin, no readahead, from 2.41sec to 1.64sec).

Cc Dan Williams <[email protected]>

Cc Ross Zwisler <[email protected]>

Cc Hugh Dickins <[email protected]>

Signed-off-by Minchan Kim <[email protected]>

---
 include/linux/swap.h | 11 +++++++++++
 mm/memory.c          | 52 ++++++++++++++++++++++++++++++++++++----------------
 mm/page_io.c         |  6 +++---
 mm/swapfile.c        | 11 +++++++----
 4 files changed, 57 insertions(+), 23 deletions(-)

include/linux/swap.h +11 -0

index fbb33919d1c6..cd2f66fdfc2d 100644
@@ -461,6 +461,7 @@ extern int page_swapcount(struct page *);
 extern int __swp_swapcount(swp_entry_t entry);
 extern int swp_swapcount(swp_entry_t entry);
 extern struct swap_info_struct *page_swap_info(struct page *);
+extern struct swap_info_struct *swp_swap_info(swp_entry_t entry);
 extern bool reuse_swap_page(struct page *, int *);
 extern int try_to_free_swap(struct page *);
 struct backing_dev_info;

@@ -469,6 +470,16 @@ extern void exit_swap_address_space(unsigned int type);
 
 #else /* CONFIG_SWAP */
 
+static inline int swap_readpage(struct page *page, bool do_poll)
+{
+       return 0;
+}
+
+static inline struct swap_info_struct *swp_swap_info(swp_entry_t entry)
+{
+       return NULL;
+}
+
 #define swap_address_space(entry)              (NULL)
 #define get_nr_swap_pages()                    0L
 #define total_swap_pages                       0L

mm/memory.c +14 -7

index ec4e15494901..163ab2062385 100644
@@ -2842,7 +2842,7 @@ EXPORT_SYMBOL(unmap_mapping_range);
 int do_swap_page(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
-       struct page *page = NULL, *swapcache;
+       struct page *page = NULL, *swapcache = NULL;
        struct mem_cgroup *memcg;
        struct vma_swap_readahead swap_ra;
        swp_entry_t entry;

@@ -2881,17 +2881,35 @@ int do_swap_page(struct vm_fault *vmf)
                }
                goto out;
        }
+
+
        delayacct_set_flag(DELAYACCT_PF_SWAPIN);
        if (!page)
                page = lookup_swap_cache(entry, vma_readahead ? vma : NULL,
                                         vmf->address);
        if (!page) {
-               if (vma_readahead)
-                       page = do_swap_page_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
-               else
-                       page = swapin_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+               struct swap_info_struct *si = swp_swap_info(entry);
+
+               if (!(si->flags & SWP_SYNCHRONOUS_IO)) {
+                       if (vma_readahead)
+                               page = do_swap_page_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
+                       else
+                               page = swapin_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       swapcache = page;
+               } else {

mm/memory.c +12 -9

+
                if (!page) {
                        /*
                         * Back out if somebody else faulted in this pte

@@ -2920,7 +2938,6 @@ int do_swap_page(struct vm_fault *vmf)
                goto out_release;
        }
 
-       swapcache = page;
        locked = lock_page_or_retry(page, vma->vm_mm, vmf->flags);
 
        delayacct_clear_flag(DELAYACCT_PF_SWAPIN);

@@ -2935,7 +2952,8 @@ int do_swap_page(struct vm_fault *vmf)
         * test below, are not enough to exclude that.  Even if it is still
         * swapcache, we need to check that the page's swap has not changed.
         */
-       if (unlikely(!PageSwapCache(page) || page_private(page) != entry.val))
+       if (unlikely((!PageSwapCache(page) ||
+                       page_private(page) != entry.val)) && swapcache)
                goto out_page;
 
        page = ksm_might_need_to_copy(page, vma, vmf->address);

@@ -2988,14 +3006,16 @@ int do_swap_page(struct vm_fault *vmf)
                pte = pte_mksoft_dirty(pte);
        set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
        vmf->orig_pte = pte;
-       if (page == swapcache) {
-               do_page_add_anon_rmap(page, vma, vmf->address, exclusive);
-               mem_cgroup_commit_charge(page, memcg, true, false);
-               activate_page(page);
-       } else { /* ksm created a completely new copy */
+
+       /* ksm created a completely new copy */
+       if (unlikely(page != swapcache && swapcache)) {
                page_add_new_anon_rmap(page, vma, vmf->address, false);
                mem_cgroup_commit_charge(page, memcg, false, false);
                lru_cache_add_active_or_unevictable(page, vma);
+       } else {
+               do_page_add_anon_rmap(page, vma, vmf->address, exclusive);
+               mem_cgroup_commit_charge(page, memcg, true, false);
+               activate_page(page);
        }
 
        swap_free(entry);

@@ -3003,7 +3023,7 @@ int do_swap_page(struct vm_fault *vmf)
            (vma->vm_flags & VM_LOCKED) || PageMlocked(page))
                try_to_free_swap(page);
        unlock_page(page);
-       if (page != swapcache) {
+       if (page != swapcache && swapcache) {
                /*
                 * Hold the lock to avoid the swap entry to be reused
                 * until we take the PT lock for the pte_same() check

@@ -3036,7 +3056,7 @@ int do_swap_page(struct vm_fault *vmf)
        unlock_page(page);
 out_release:
        put_page(page);
-       if (page != swapcache) {
+       if (page != swapcache && swapcache) {
                unlock_page(swapcache);
                put_page(swapcache);
        }

mm/page_io.c +3 -3

index 21502d341a67..d4a98e1f6608 100644
@@ -346,7 +346,7 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,
        return ret;
 }
 
-int swap_readpage(struct page *page, bool do_poll)
+int swap_readpage(struct page *page, bool synchronous)
 {
        struct bio *bio;
        int ret = 0;

@@ -354,7 +354,7 @@ int swap_readpage(struct page *page, bool do_poll)
        blk_qc_t qc;
        struct gendisk *disk;
 
-       VM_BUG_ON_PAGE(!PageSwapCache(page), page);
+       VM_BUG_ON_PAGE(!PageSwapCache(page) && !synchronous, page);
        VM_BUG_ON_PAGE(!PageLocked(page), page);
        VM_BUG_ON_PAGE(PageUptodate(page), page);
        if (frontswap_load(page) == 0) {

@@ -402,7 +402,7 @@ int swap_readpage(struct page *page, bool do_poll)
        count_vm_event(PSWPIN);
        bio_get(bio);
        qc = submit_bio(bio);
-       while (do_poll) {
+       while (synchronous) {
                set_current_state(TASK_UNINTERRUPTIBLE);
                if (!READ_ONCE(bio->bi_private))
                        break;

mm/swapfile.c +7 -5

index 1305591cde4d..64a3d85226ba 100644
@@ -3454,10 +3454,15 @@ int swapcache_prepare(swp_entry_t entry)
        return __swap_duplicate(entry, SWAP_HAS_CACHE);
 }
 
+struct swap_info_struct *swp_swap_info(swp_entry_t entry)
+{
+       return swap_info[swp_type(entry)];
+}
+
 struct swap_info_struct *page_swap_info(struct page *page)
 {
-       swp_entry_t swap = { .val = page_private(page) };
-       return swap_info[swp_type(swap)];
+       swp_entry_t entry = { .val = page_private(page) };
+       return swp_swap_info(entry);
 }
 
 /*

@@ -3465,7 +3470,6 @@ struct swap_info_struct *page_swap_info(struct page *page)
  */
 struct address_space *__page_file_mapping(struct page *page)
 {
-       VM_BUG_ON_PAGE(!PageSwapCache(page), page);
        return page_swap_info(page)->swap_file->f_mapping;
 }
 EXPORT_SYMBOL_GPL(__page_file_mapping);

@@ -3473,7 +3477,6 @@ EXPORT_SYMBOL_GPL(__page_file_mapping);
 pgoff_t __page_file_index(struct page *page)
 {
        swp_entry_t swap = { .val = page_private(page) };
-       VM_BUG_ON_PAGE(!PageSwapCache(page), page);
        return swp_offset(swap);
 }
 EXPORT_SYMBOL_GPL(__page_file_index);
--

2.7.4

On Wed, Sep 20, 2017 at 1:43 PM, Minchan Kim <[email protected]> wrote:

Quoted 41 lines

mm/memory.c +14 -7

index ec4e15494901..163ab2062385 100644
@@ -2842,7 +2842,7 @@ EXPORT_SYMBOL(unmap_mapping_range);
 int do_swap_page(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
-       struct page *page = NULL, *swapcache;
+       struct page *page = NULL, *swapcache = NULL;
        struct mem_cgroup *memcg;
        struct vma_swap_readahead swap_ra;
        swp_entry_t entry;

@@ -2881,17 +2881,35 @@ int do_swap_page(struct vm_fault *vmf)
                }
                goto out;
        }
+
+
        delayacct_set_flag(DELAYACCT_PF_SWAPIN);
        if (!page)
                page = lookup_swap_cache(entry, vma_readahead ? vma : NULL,
                                         vmf->address);
        if (!page) {
-               if (vma_readahead)
-                       page = do_swap_page_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
-               else
-                       page = swapin_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+               struct swap_info_struct *si = swp_swap_info(entry);
+
+               if (!(si->flags & SWP_SYNCHRONOUS_IO)) {
+                       if (vma_readahead)
+                               page = do_swap_page_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
+                       else
+                               page = swapin_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       swapcache = page;
+               } else {

mm/memory.c int do_swap_page(struct vm_fault *vmf) · line 2911

Quoted 10 lines

mm/memory.c +10 -0

+                       /* skip swapcache */
+                       page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       if (page) {
+                               __SetPageLocked(page);
+                               __SetPageSwapBacked(page);
+                               set_page_private(page, entry.val);
+                               lru_cache_add_anon(page);
+                               swap_readpage(page, true);
+                       }
+               }

I have a question for this. If a page is mapped in multiple processes (for example, because of fork). With swap cache, after swapping out and swapping in, the page will be still shared by these processes. But with your changes, it appears that there will be multiple pages with same contents mapped in multiple processes, even if the page isn't written in these processes. So this may waste some memory in some situation? And copying from device is even faster than looking up swap cache in your system?

Quoted 93 lines · Minchan Kim

With fast swap storage, platform want to use swap more aggressively and swap-in is crucial to application latency.

The rw_page based synchronous devices like zram, pmem and btt are such fast storage. When I profile swapin performance with zram lz4 decompress test, S/W overhead is more than 70%. Maybe, it would be bigger in nvdimm.

This patch aims for reducing swap-in latency via skipping swapcache if swap device is synchronous device like rw_page based device. It enhances 45% my swapin test(5G sequential swapin, no readahead, from 2.41sec to 1.64sec).

Cc Dan Williams <[email protected]>

Cc Ross Zwisler <[email protected]>

Cc Hugh Dickins <[email protected]>

Signed-off-by Minchan Kim <[email protected]>

---
 include/linux/swap.h | 11 +++++++++++
 mm/memory.c          | 52 ++++++++++++++++++++++++++++++++++++----------------
 mm/page_io.c         |  6 +++---
 mm/swapfile.c        | 11 +++++++----
 4 files changed, 57 insertions(+), 23 deletions(-)

include/linux/swap.h +11 -0

index fbb33919d1c6..cd2f66fdfc2d 100644
@@ -461,6 +461,7 @@ extern int page_swapcount(struct page *);
 extern int __swp_swapcount(swp_entry_t entry);
 extern int swp_swapcount(swp_entry_t entry);
 extern struct swap_info_struct *page_swap_info(struct page *);
+extern struct swap_info_struct *swp_swap_info(swp_entry_t entry);
 extern bool reuse_swap_page(struct page *, int *);
 extern int try_to_free_swap(struct page *);
 struct backing_dev_info;

@@ -469,6 +470,16 @@ extern void exit_swap_address_space(unsigned int type);
 
 #else /* CONFIG_SWAP */
 
+static inline int swap_readpage(struct page *page, bool do_poll)
+{
+       return 0;
+}
+
+static inline struct swap_info_struct *swp_swap_info(swp_entry_t entry)
+{
+       return NULL;
+}
+
 #define swap_address_space(entry)              (NULL)
 #define get_nr_swap_pages()                    0L
 #define total_swap_pages                       0L

mm/memory.c +14 -7

index ec4e15494901..163ab2062385 100644
@@ -2842,7 +2842,7 @@ EXPORT_SYMBOL(unmap_mapping_range);
 int do_swap_page(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
-       struct page *page = NULL, *swapcache;
+       struct page *page = NULL, *swapcache = NULL;
        struct mem_cgroup *memcg;
        struct vma_swap_readahead swap_ra;
        swp_entry_t entry;

@@ -2881,17 +2881,35 @@ int do_swap_page(struct vm_fault *vmf)
                }
                goto out;
        }
+
+
        delayacct_set_flag(DELAYACCT_PF_SWAPIN);
        if (!page)
                page = lookup_swap_cache(entry, vma_readahead ? vma : NULL,
                                         vmf->address);
        if (!page) {
-               if (vma_readahead)
-                       page = do_swap_page_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
-               else
-                       page = swapin_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+               struct swap_info_struct *si = swp_swap_info(entry);
+
+               if (!(si->flags & SWP_SYNCHRONOUS_IO)) {
+                       if (vma_readahead)
+                               page = do_swap_page_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
+                       else
+                               page = swapin_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       swapcache = page;
+               } else {

mm/memory.c int do_swap_page(struct vm_fault *vmf) · line 2911

Quoted 10 lines

mm/memory.c +10 -0

+                       /* skip swapcache */
+                       page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       if (page) {
+                               __SetPageLocked(page);
+                               __SetPageSwapBacked(page);
+                               set_page_private(page, entry.val);
+                               lru_cache_add_anon(page);
+                               swap_readpage(page, true);
+                       }
+               }

I have a question for this. If a page is mapped in multiple processes (for example, because of fork). With swap cache, after swapping out and swapping in, the page will be still shared by these processes. But with your changes, it appears that there will be multiple pages with same contents mapped in multiple processes, even if the page isn't written in these processes. So this may waste some memory in some situation? And copying from device is even faster than looking up swap cache in your system?

Hi Huang,

Sorry for the late response. It was long national holiday.

Quoted 105 lines · huang ying

Quoted 93 lines · Minchan Kim

With fast swap storage, platform want to use swap more aggressively and swap-in is crucial to application latency.

The rw_page based synchronous devices like zram, pmem and btt are such fast storage. When I profile swapin performance with zram lz4 decompress test, S/W overhead is more than 70%. Maybe, it would be bigger in nvdimm.

This patch aims for reducing swap-in latency via skipping swapcache if swap device is synchronous device like rw_page based device. It enhances 45% my swapin test(5G sequential swapin, no readahead, from 2.41sec to 1.64sec).

Cc Dan Williams <[email protected]>

Cc Ross Zwisler <[email protected]>

Cc Hugh Dickins <[email protected]>

Signed-off-by Minchan Kim <[email protected]>

---
 include/linux/swap.h | 11 +++++++++++
 mm/memory.c          | 52 ++++++++++++++++++++++++++++++++++++----------------
 mm/page_io.c         |  6 +++---
 mm/swapfile.c        | 11 +++++++----
 4 files changed, 57 insertions(+), 23 deletions(-)

include/linux/swap.h +11 -0

index fbb33919d1c6..cd2f66fdfc2d 100644
@@ -461,6 +461,7 @@ extern int page_swapcount(struct page *);
 extern int __swp_swapcount(swp_entry_t entry);
 extern int swp_swapcount(swp_entry_t entry);
 extern struct swap_info_struct *page_swap_info(struct page *);
+extern struct swap_info_struct *swp_swap_info(swp_entry_t entry);
 extern bool reuse_swap_page(struct page *, int *);
 extern int try_to_free_swap(struct page *);
 struct backing_dev_info;

@@ -469,6 +470,16 @@ extern void exit_swap_address_space(unsigned int type);
 
 #else /* CONFIG_SWAP */
 
+static inline int swap_readpage(struct page *page, bool do_poll)
+{
+       return 0;
+}
+
+static inline struct swap_info_struct *swp_swap_info(swp_entry_t entry)
+{
+       return NULL;
+}
+
 #define swap_address_space(entry)              (NULL)
 #define get_nr_swap_pages()                    0L
 #define total_swap_pages                       0L

mm/memory.c +14 -7

index ec4e15494901..163ab2062385 100644
@@ -2842,7 +2842,7 @@ EXPORT_SYMBOL(unmap_mapping_range);
 int do_swap_page(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
-       struct page *page = NULL, *swapcache;
+       struct page *page = NULL, *swapcache = NULL;
        struct mem_cgroup *memcg;
        struct vma_swap_readahead swap_ra;
        swp_entry_t entry;

@@ -2881,17 +2881,35 @@ int do_swap_page(struct vm_fault *vmf)
                }
                goto out;
        }
+
+
        delayacct_set_flag(DELAYACCT_PF_SWAPIN);
        if (!page)
                page = lookup_swap_cache(entry, vma_readahead ? vma : NULL,
                                         vmf->address);
        if (!page) {
-               if (vma_readahead)
-                       page = do_swap_page_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
-               else
-                       page = swapin_readahead(entry,
-                               GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+               struct swap_info_struct *si = swp_swap_info(entry);
+
+               if (!(si->flags & SWP_SYNCHRONOUS_IO)) {
+                       if (vma_readahead)
+                               page = do_swap_page_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
+                       else
+                               page = swapin_readahead(entry,
+                                       GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       swapcache = page;
+               } else {

mm/memory.c int do_swap_page(struct vm_fault *vmf) · line 2911

Quoted 10 lines

mm/memory.c +10 -0

+                       /* skip swapcache */
+                       page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+                       if (page) {
+                               __SetPageLocked(page);
+                               __SetPageSwapBacked(page);
+                               set_page_private(page, entry.val);
+                               lru_cache_add_anon(page);
+                               swap_readpage(page, true);
+                       }
+               }

Quoted 8 lines

I have a question for this. If a page is mapped in multiple processes (for example, because of fork). With swap cache, after swapping out and swapping in, the page will be still shared by these processes. But with your changes, it appears that there will be multiple pages with same contents mapped in multiple processes, even if the page isn't written in these processes. So this may waste some memory in some situation? And copying from device is even faster than looking up swap cache in your system?

I expected a page shared by several processes has low possibility to swap out compared to a single mapped page. Nonetheless, once it is swapped out, it also has low chance to swap in so I didn't cover the case intentionally until we get any regression report.

However, a fix would be simple so I don't care to add up it. Any thoughts?

include/linux/swap.h +6 -0

index cd2f66fdfc2d..23f19ffa5cc3 100644
@@ -458,6 +458,7 @@ extern unsigned int count_swap_pages(int, int);
 extern sector_t map_swap_page(struct page *, struct block_device **);
 extern sector_t swapdev_block(int, pgoff_t);
 extern int page_swapcount(struct page *);
+extern int __swap_count(struct swap_info_struct *si, swp_entry_t entry);
 extern int __swp_swapcount(swp_entry_t entry);
 extern int swp_swapcount(swp_entry_t entry);
 extern struct swap_info_struct *page_swap_info(struct page *);

@@ -584,6 +585,11 @@ static inline int page_swapcount(struct page *page)
 	return 0;
 }
 
+static inline int __swap_count(structd swap_info_struct *si, swp_entry_t entry)
+{
+	return 0;
+}
+
 static inline int __swp_swapcount(swp_entry_t entry)
 {
 	return 0;

include/linux/swapfile.h +0 -1

index 388293a91e8c..49f8e19dd506 100644
@@ -9,5 +9,4 @@ extern spinlock_t swap_lock;
 extern struct plist_head swap_active_head;
 extern struct swap_info_struct *swap_info[];
 extern int try_to_unuse(unsigned int, bool, unsigned long);
-
 #endif /* _LINUX_SWAPFILE_H */

mm/memory.c +10 -9

index 163ab2062385..c6f0abe8b39b 100644
@@ -2890,15 +2890,8 @@ int do_swap_page(struct vm_fault *vmf)
 	if (!page) {
 		struct swap_info_struct *si = swp_swap_info(entry);
 
-		if (!(si->flags & SWP_SYNCHRONOUS_IO)) {
-			if (vma_readahead)
-				page = do_swap_page_readahead(entry,
-					GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
-			else
-				page = swapin_readahead(entry,
-					GFP_HIGHUSER_MOVABLE, vma, vmf->address);
-			swapcache = page;
-		} else {
+		if ((si->flags & SWP_SYNCHRONOUS_IO) && (vmf->flags & FAULT_FLAG_WRITE ||
+							__swap_count(si, entry) == 1)) {
 			/* skip swapcache */
 			page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, vmf->address);
 			if (page) {

@@ -2908,6 +2901,14 @@ int do_swap_page(struct vm_fault *vmf)
 				lru_cache_add_anon(page);
 				swap_readpage(page, true);
 			}
+		} else {
+			if (vma_readahead)
+				page = do_swap_page_readahead(entry,
+					GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
+			else
+				page = swapin_readahead(entry,
+					GFP_HIGHUSER_MOVABLE, vma, vmf->address);
+			swapcache = page;
 		}
 
 		if (!page) {

mm/swapfile.c +0 -1

index 64a3d85226ba..37d7ba71a2ca 100644
@@ -1328,7 +1328,13 @@ int page_swapcount(struct page *page)
 	return count;
 }
 
-static int swap_swapcount(struct swap_info_struct *si, swp_entry_t entry)