mm, THP, swap: Swapout/swapin THP in one piece
Subsystems (21)
cover mm, THP, swap: Swapout/swapin THP in one piece
From: Huang Ying <[email protected]>
Hi, Andrew, could you help me to check whether the overall design is reasonable?
Hi, Hugh, Shaohua, Minchan and Rik, could you help me to review the swap part of the patchset? Especially [02/21], [03/21], [04/21], [05/21], [06/21], [07/21], [08/21], [09/21], [10/21], [11/21], [12/21], [20/21].
Hi, Andrea and Kirill, could you help me to review the THP part of the patchset? Especially [01/21], [07/21], [09/21], [11/21], [13/21], [15/21], [16/21], [17/21], [18/21], [19/21], [20/21], [21/21].
Hi, Johannes and Michal, could you help me to review the cgroup part of the patchset? Especially [14/21].
And for all, Any comment is welcome!
This patchset is based on the 2018-05-18 head of mmotm/master.
This is the final step of THP (Transparent Huge Page) swap optimization. After the first and second step, the splitting huge page is delayed from almost the first step of swapout to after swapout has been finished. In this step, we avoid splitting THP for swapout and swapout/swapin the THP in one piece.
We tested the patchset with vm-scalability benchmark swap-w-seq test case, with 16 processes. The test case forks 16 processes. Each process allocates large anonymous memory range, and writes it from begin to end for 8 rounds. The first round will swapout, while the remaining rounds will swapin and swapout. The test is done on a Xeon E5 v3 system, the swap device used is a RAM simulated PMEM (persistent memory) device. The test result is as follow,
base optimized
---------------- --------------------------
%stddev %change %stddev
\ | \
1417897 A+- 2% +992.8% 15494673 vm-scalability.throughput
1020489 A+- 4% +1091.2% 12156349 vmstat.swap.si
1255093 A+- 3% +940.3% 13056114 vmstat.swap.so
1259769 A+- 7% +1818.3% 24166779 meminfo.AnonHugePages
28021761 -10.7% 25018848 A+- 2% meminfo.AnonPages
64080064 A+- 4% -95.6% 2787565 A+- 33% interrupts.CAL:Function_call_interrupts
13.91 A+- 5% -13.8 0.10 A+- 27% perf-profile.children.cycles-pp.native_queued_spin_lock_slowpathWhere, the score of benchmark (bytes written per second) improved 992.8%. The swapout/swapin throughput improved 1008% (from about 2.17GB/s to 24.04GB/s). The performance difference is huge. In base kernel, for the first round of writing, the THP is swapout and split, so in the remaining rounds, there is only normal page swapin and swapout. While in optimized kernel, the THP is kept after first swapout, so THP swapin and swapout is used in the remaining rounds. This shows the key benefit to swapout/swapin THP in one piece, the THP will be kept instead of being split. meminfo information verified this, in base kernel only 4.5% of anonymous page are THP during the test, while in optimized kernel, that is 96.6%. The TLB flushing IPI (represented as interrupts.CAL:Function_call_interrupts) reduced 95.6%, while cycles for spinlock reduced from 13.9% to 0.1%. These are performance benefit of THP swapout/swapin too.
Below is the description for all steps of THP swap optimization.
Recently, the performance of the storage devices improved so fast that we cannot saturate the disk bandwidth with single logical CPU when do page swapping even on a high-end server machine. Because the performance of the storage device improved faster than that of single logical CPU. And it seems that the trend will not change in the near future. On the other hand, the THP becomes more and more popular because of increased memory size. So it becomes necessary to optimize THP swap performance.
The advantages to swapout/swapin a THP in one piece include:
- Batch various swap operations for the THP. Many operations need to be done once per THP instead of per normal page, for example, allocating/freeing the swap space, writing/reading the swap space, flushing TLB, page fault, etc. This will improve the performance of the THP swap greatly.
- The THP swap space read/write will be large sequential IO (2M on x86_64). It is particularly helpful for the swapin, which are usually 4k random IO. This will improve the performance of the THP swap too.
- It will help the memory fragmentation, especially when the THP is heavily used by the applications. The THP order pages will be free up after THP swapout.
- It will improve the THP utilization on the system with the swap turned on. Because the speed for khugepaged to collapse the normal pages into the THP is quite slow. After the THP is split during the swapout, it will take quite long time for the normal pages to collapse back into the THP after being swapin. The high THP utilization helps the efficiency of the page based memory management too.
There are some concerns regarding THP swapin, mainly because possible enlarged read/write IO size (for swapout/swapin) may put more overhead on the storage device. To deal with that, the THP swapin is turned on only when necessary. A new sysfs interface:/sys/kernel/mm/transparent_hugepage/swapin_enabled is added to configure it. It uses "always/never/madvise" logic, to be turned on globally, turned off globally, or turned on only for VMA with MADV_HUGEPAGE, etc.
GE, etc.
Changelog
---------
v3:
- Rebased on 5/18 HEAD of mmotm/master
- Fixed a build bug, Thanks 0-Day!
v2:
- Fixed several build bugs, Thanks 0-Day!
- Improved documentation as suggested by Randy Dunlap.
- Fixed several bugs in reading huge swap cluster
PATCH 1/21 mm, THP, swap: Enable PMD swap operations for CONFIG_THP_SWAP
From: Huang Ying <[email protected]>
Previously, the PMD swap operations are only enabled for CONFIG_ARCH_ENABLE_THP_MIGRATION. Because they are only used by the THP migration support. We will support PMD swap mapping to the huge swap cluster and swapin the THP as a whole. That will be enabled via CONFIG_THP_SWAP and needs these PMD swap operations. So enable the PMD swap operations for CONFIG_THP_SWAP too.
--- arch/x86/include/asm/pgtable.h | 2 +- include/asm-generic/pgtable.h | 2 +- include/linux/swapops.h | 44 ++++++++++++++++++++++-------------------- 3 files changed, 25 insertions(+), 23 deletions(-)
arch/x86/include/asm/pgtable.h +1 -1
@@ -1224,7 +1224,7 @@ static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)return pte_clear_flags (pte, _PAGE_SWP_SOFT_DIRTY); } -#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION +#if defined(CONFIG_ARCH_ENABLE_THP_MIGRATION ) || defined(CONFIG_THP_SWAP )static inline pmd_t pmd_swp_mksoft_dirty (pmd_t pmd) {return pmd_set_flags (pmd, _PAGE_SWP_SOFT_DIRTY);
include/asm-generic/pgtable.h +1 -1
@@ -675,7 +675,7 @@ static inline void ptep_modify_prot_commit(struct mm_struct *mm,#endif #ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY -#ifndef CONFIG_ARCH_ENABLE_THP_MIGRATION +#if !defined(CONFIG_ARCH_ENABLE_THP_MIGRATION) && !defined(CONFIG_THP_SWAP) static inline pmd_t pmd_swp_mksoft_dirty(pmd_t pmd) { return pmd;
include/linux/swapops.h +23 -21
62 lines not on this page · raw message
Signature · 1 line
2.16.1
PATCH 2/21 mm, THP, swap: Make CONFIG_THP_SWAP depends on CONFIG_SWAP
In reply to Huang, YingFrom: Huang Ying <[email protected]>
It's unreasonable to optimize swapping for THP without basic swapping support. And this will cause build errors when THP_SWAP functions are defined in swapfile.c and called elsewhere.
The comments are fixed too to reflect the latest progress.
--- mm/Kconfig | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
mm/Kconfig +1 -2
@@ -420,10 +420,9 @@ config ARCH_WANTS_THP_SWAP config THP_SWAP def_bool y - depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP + depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP help Swap transparent huge pages in one piece, without splitting. - XXX: For now this only does clustered swap space allocation. For selection by architectures with reasonable THP sizes.
Signature · 1 line
2.16.1
PATCH 3/21 mm, THP, swap: Support PMD swap mapping in swap_duplicate()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
To support to swapin the THP as a whole, we need to create PMD swap mapping during swapout, and maintain PMD swap mapping count. This patch implements the support to increase the PMD swap mapping count (for swapout, fork, etc.) and set SWAP_HAS_CACHE flag (for swapin, etc.) for a huge swap cluster in swap_duplicate() function family. Although it only implements a part of the design of the swap reference count with PMD swap mapping, the whole design is described as follow to make it easy to understand the patch and the whole picture.
A huge swap cluster is used to hold the contents of a swapouted THP. After swapout, a PMD page mapping to the THP will become a PMD swap mapping to the huge swap cluster via a swap entry in PMD. While a PTE page mapping to a subpage of the THP will become the PTE swap mapping to a swap slot in the huge swap cluster via a swap entry in PTE.
If there is no PMD swap mapping and the corresponding THP is removed from the page cache (reclaimed), the huge swap cluster will be split and become a normal swap cluster.
The count (cluster_count()) of the huge swap cluster is SWAPFILE_CLUSTER (= HPAGE_PMD_NR) + PMD swap mapping count. Because all swap slots in the huge swap cluster are mapped by PTE or PMD, or has SWAP_HAS_CACHE bit set, the usage count of the swap cluster is HPAGE_PMD_NR. And the PMD swap mapping count is recorded too to make it easy to determine whether there are remaining PMD swap mappings.
The count in swap_map[offset] is the sum of PTE and PMD swap mapping count. This means when we increase the PMD swap mapping count, we need to increase swap_map[offset] for all swap slots inside the swap cluster. An alternative choice is to make swap_map[offset] to record PTE swap map count only, given we have recorded PMD swap mapping count in the count of the huge swap cluster. But this need to increase swap_map[offset] when splitting the PMD swap mapping, that may fail because of memory allocation for swap count continuation. That is hard to dealt with. So we choose current solution.
The PMD swap mapping to a huge swap cluster may be split when unmap a part of PMD mapping etc. That is easy because only the count of the huge swap cluster need to be changed. When the last PMD swap mapping is gone and SWAP_HAS_CACHE is unset, we will split the huge swap cluster (clear the huge flag). This makes it easy to reason the cluster state.
A huge swap cluster will be split when splitting the THP in swap cache, or failing to allocate THP during swapin, etc. But when splitting the huge swap cluster, we will not try to split all PMD swap mappings, because we haven't enough information available for that sometimes. Later, when the PMD swap mapping is duplicated or swapin, etc, the PMD swap mapping will be split and fallback to the PTE operation.
When a THP is added into swap cache, the SWAP_HAS_CACHE flag will be set in the swap_map[offset] of all swap slots inside the huge swap cluster backing the THP. This huge swap cluster will not be split unless the THP is split even if its PMD swap mapping count dropped to
0. Later, when the THP is removed from swap cache, the SWAP_HAS_CACHE flag will be cleared in the swap_map[offset] of all swap slots inside the huge swap cluster. And this huge swap cluster will be split if its PMD swap mapping count is 0.
--- include/linux/huge_mm.h | 5 + include/linux/swap.h | 9 +- mm/memory.c | 2 +- mm/rmap.c | 2 +- mm/swapfile.c | 287 +++++++++++++++++++++++++++++++++--------------- 5 files changed, 213 insertions(+), 92 deletions(-)
include/linux/huge_mm.h +5 -0
@@ -79,6 +79,11 @@ extern struct kobj_attribute shmem_enabled_attr;#define HPAGE_PMD_ORDER (HPAGE_PMD_SHIFT-PAGE_SHIFT)#define HPAGE_PMD_NR (1<<HPAGE_PMD_ORDER) +static inline bool thp_swap_supported (void ) +{ +return IS_ENABLED (CONFIG_THP_SWAP ); +} +#ifdef CONFIG_TRANSPARENT_HUGEPAGE #define HPAGE_PMD_SHIFT PMD_SHIFT#define HPAGE_PMD_SIZE ((1UL) << HPAGE_PMD_SHIFT)
include/linux/swap.h +5 -4
@@ -451,8 +451,8 @@ extern swp_entry_t get_swap_page_of_type(int);extern int get_swap_pages (int n,bool cluster,swp_entry_t swp_entries[]);extern int add_swap_count_continuation (swp_entry_t ,gfp_t );extern void swap_shmem_alloc (swp_entry_t ); -extern int swap_duplicate (swp_entry_t ); -extern int swapcache_prepare (swp_entry_t ); +extern int swap_duplicate (swp_entry_t *entry,bool cluster); +extern int swapcache_prepare (swp_entry_t entry,bool cluster);extern void swap_free (swp_entry_t );extern void swapcache_free_entries (swp_entry_t *entries,int n);extern int free_swap_and_cache (swp_entry_t );
@@ -510,7 +510,8 @@ static inline void show_swap_cache_info(void) }#define free_swap_and_cache (e) ({(is_migration_entry(e) || is_device_private_entry(e));}) -#define swapcache_prepare (e) ({(is_migration_entry(e) || is_device_private_entry(e));}) +#define swapcache_prepare (e, c) \ + ({(is_migration_entry(e) || is_device_private_entry(e)); })static inline int add_swap_count_continuation (swp_entry_t swp,gfp_t gfp_mask) {
@@ -521,7 +522,7 @@ static inline void swap_shmem_alloc(swp_entry_t swp) { } -static inline int swap_duplicate (swp_entry_t swp) +static inline int swap_duplicate (swp_entry_t *swp,bool cluster) {return 0 ; }
mm/memory.c +1 -1
@@ -951,7 +951,7 @@ copy_one_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,swp_entry_t entry =pte_to_swp_entry (pte);if (likely (!non_swap_entry (entry))) { -if (swap_duplicate (entry) <0 ) +if (swap_duplicate (&entry, false) <0 )return entry.val;/* make sure dst_mm is on swapoff's mmlist. */
mm/rmap.c +1 -1
@@ -1556,7 +1556,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,break ; } -if (swap_duplicate (entry) <0 ) { +if (swap_duplicate (&entry, false) <0 ) {set_pte_at (mm, address, pvmw.pte, pteval); ret = false;page_vma_mapped_walk_done (&pvmw);
mm/swapfile.c +201 -86
388 lines not on this page · raw message
Signature · 1 line
2.16.1
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
Hi,
The series up to and including this patch doesn't build. For this patch we need:
mm/swap_state.c +1 -1
@@ -433,7 +433,7 @@ struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,/* * Swap entry may have been freed since our caller observed it. */ - err =swapcache_prepare (entry); + err =swapcache_prepare (entry, false);if (err == -EEXIST ) {radix_tree_preload_end ();/*
Review static int __swap_duplicate(swp_entry_t entry, unsigned char usage)
Quoted 1 line · Ying
(quoted diff) +0
-0@@ -3516,11 +3512,39 @@ static int __swap_duplicate(swp_entry_t entry, unsigned char usage)
Two comments about this part of __swap_duplicate as long as you're moving it to another function:
} else if (count || has_cache) {
if ((count & ~COUNT_CONTINUED) < SWAP_MAP_MAX) /* #1 */
count += usage;
else if ((count & ~COUNT_CONTINUED) > SWAP_MAP_MAX) /* #2 */
err = -EINVAL;#1: __swap_duplicate_locked might use
VM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);
to document the unstated assumption that usage is 1 (otherwise count could overflow).
#2: We've masked off SWAP_HAS_CACHE and COUNT_CONTINUED, and already checked for SWAP_MAP_BAD, so I think condition #2 always fails and can just be removed.
Quoted 2 lines
(quoted diff) +2
-0+#ifdef CONFIG_THP_SWAP +static int __swap_duplicate_cluster(swp_entry_t *entry, unsigned char usage)
...
Review
Quoted 4 lines
(quoted diff) +4
-0+ } else { + for (i = 0; i < SWAPFILE_CLUSTER; i++) { +retry: + err = __swap_duplicate_locked(si, offset + i, 1);
I guess usage is assumed to be 1 at this point (__swap_duplicate_locked makes the same assumption). Maybe make this explicit with
err = __swap_duplicate_locked(si, offset + i, usage);
, use 'usage' in cluster_set_count and __swap_entry_free too, and then earlier have a
VM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);
?
Review
Quoted 2 lines
(quoted diff) +2
-0+#else +static inline int __swap_duplicate_cluster(swp_entry_t *entry,
This doesn't need inline.
Not related to your changes, but while we're here, the comment with SWAP_HAS_CONT in swap_count() could be deleted: I don't think there ever was a SWAP_HAS_CONT.
The rest looks ok up to this point.
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
Hi, Daniel,
Thanks for your effort to review this series.
Quoted 10 lines · Daniel Jordan
Hi,
The series up to and including this patch doesn't build. For this patch we need:
mm/swap_state.c +0
-0
mm/swap_state.c struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask, · line 439
Quoted 8 lines
mm/swap_state.c +1
-1@@ -433,7 +433,7 @@ struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,/* * Swap entry may have been freed since our caller observed it. */ - err =swapcache_prepare (entry); + err =swapcache_prepare (entry, false);if (err == -EEXIST ) {radix_tree_preload_end ();/*
Thanks for pointing this out! Will change in the next version.
Quoted 14 lines · Ying
Review static int __swap_duplicate(swp_entry_t entry, unsigned char usage)
Quoted 1 line
(quoted diff) +0
-0@@ -3516,11 +3512,39 @@ static int __swap_duplicate(swp_entry_t entry, unsigned char usage)Two comments about this part of
__swap_duplicateas long as you're moving it to another function:} else if (count || has_cache) { if ((count & ~COUNT_CONTINUED) < SWAP_MAP_MAX) /* #1 */ count += usage; else if ((count & ~COUNT_CONTINUED) > SWAP_MAP_MAX) /* #2 */ err = -EINVAL;
Quoted 6 lines
#1:
__swap_duplicate_lockedmight useVM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);to document the unstated assumption that usage is 1 (otherwise count could overflow).
Sounds good. Will do this.
Quoted 2 lines
#2: We've masked off
SWAP_HAS_CACHEandCOUNT_CONTINUED, and already checked forSWAP_MAP_BAD, so I think condition #2 always fails and can just be removed.
I think this is used to check some software bug. For example, SWAP_MAP_SHMEM will yield true here.
Quoted 11 lines
Quoted 2 lines
(quoted diff) +2
-0+#ifdef CONFIG_THP_SWAP +static int __swap_duplicate_cluster(swp_entry_t *entry, unsigned char usage)...
Review
Quoted 4 lines
(quoted diff) +4
-0+ } else { + for (i = 0; i < SWAPFILE_CLUSTER; i++) { +retry: + err = __swap_duplicate_locked(si, offset + i, 1);I guess usage is assumed to be 1 at this point (
__swap_duplicate_lockedmakes the same assumption). Maybe make this explicit with
Quoted 8 lines
err = __swap_duplicate_locked(si, offset + i, usage);, use 'usage' in
cluster_set_countand__swap_entry_freetoo, and then earlier have aVM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);?
Yes. I will fix this. And we can just check it in __swap_duplicate_locked() and all these will be covered.
Quoted 4 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+#else +static inline int __swap_duplicate_cluster(swp_entry_t *entry,This doesn't need inline.
Why not? This is just a one line stub.
Quoted 3 lines
Not related to your changes, but while we're here, the comment with
SWAP_HAS_CONTinswap_count()could be deleted: I don't think there ever was aSWAP_HAS_CONT.
Yes. We should correct this. Because this should go to a separate patch, would you mind to submit a patch to fix it?
Quoted 1 line
The rest looks ok up to this point.
Thanks!
Best Regards,
Huang, Ying
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
Quoted 13 lines · Ying
Quoted 13 lines · Ying
Review static int __swap_duplicate(swp_entry_t entry, unsigned char usage)
Quoted 1 line
(quoted diff) +0
-0@@ -3516,11 +3512,39 @@ static int __swap_duplicate(swp_entry_t entry, unsigned char usage)Two comments about this part of
__swap_duplicateas long as you're moving it to another function:} else if (count || has_cache) { if ((count & ~COUNT_CONTINUED) < SWAP_MAP_MAX) /* #1 */ count += usage; else if ((count & ~COUNT_CONTINUED) > SWAP_MAP_MAX) /* #2 */ err = -EINVAL;
Quoted 8 lines
Quoted 6 lines
#1:
__swap_duplicate_lockedmight useVM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);to document the unstated assumption that usage is 1 (otherwise count could overflow).
Sounds good. Will do this.
Found usage parameter of __swap_duplicate() could be SWAP_MAP_SHMEM too. We can improve the parameter checking. But that appears not belong to this series.
Best Regards,
Huang, Ying
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
Quoted 18 lines · Ying
Quoted 17 lines · Ying
Quoted 17 lines · Ying
Review static int __swap_duplicate(swp_entry_t entry, unsigned char usage)
Quoted 1 line
(quoted diff) +0
-0@@ -3516,11 +3512,39 @@ static int __swap_duplicate(swp_entry_t entry, unsigned char usage)Two comments about this part of
__swap_duplicateas long as you're moving it to another function:} else if (count || has_cache) { if ((count & ~COUNT_CONTINUED) < SWAP_MAP_MAX) /* #1 */ count += usage; else if ((count & ~COUNT_CONTINUED) > SWAP_MAP_MAX) /* #2 */ err = -EINVAL;#1:
__swap_duplicate_lockedmight useVM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
to document the unstated assumption that usage is 1 (otherwise count could overflow).
Sounds good. Will do this.
Found usage parameter of
__swap_duplicate()could beSWAP_MAP_SHMEMtoo. We can improve the parameter checking. But that appears not belong to this series.
Fair enough, I'll see about adding this along with the other patch I'm sending.
Daniel
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
In reply to Huang, YingQuoted 6 lines · Ying
Quoted 2 lines · Daniel Jordan
#2: We've masked off
SWAP_HAS_CACHEandCOUNT_CONTINUED, and already checked forSWAP_MAP_BAD, so I think condition #2 always fails and can just be removed.I think this is used to check some software bug. For example,
SWAP_MAP_SHMEMwill yield true here.
So it does! And so __swap_duplicate returns -EINVAL in that case, which swap_shmem_alloc just ignores. Confusing, and an explicit check for SWAP_MAP_SHMEM would be cleaner, but why fix what isn't broken.
Quoted 17 lines
Quoted 17 lines
Quoted 3 lines
(quoted diff) +2
-0+#ifdef CONFIG_THP_SWAP +static int __swap_duplicate_cluster(swp_entry_t *entry, unsigned char usage)...
Review
Quoted 4 lines
(quoted diff) +4
-0+ } else { + for (i = 0; i < SWAPFILE_CLUSTER; i++) { +retry: + err = __swap_duplicate_locked(si, offset + i, 1);I guess usage is assumed to be 1 at this point (
__swap_duplicate_lockedmakes the same assumption). Maybe make this explicit witherr = __swap_duplicate_locked(si, offset + i, usage);, use 'usage' in
cluster_set_countand__swap_entry_freetoo, and then earlier have a
Quoted 6 lines
Quoted 3 lines
VM_BUG_ON(usage != SWAP_HAS_CACHE && usage != 1);?
Yes. I will fix this. And we can just check it in
__swap_duplicate_locked()and all these will be covered.
I'll respond to your other mail.
Quoted 6 lines
Quoted 3 lines
Not related to your changes, but while we're here, the comment with
SWAP_HAS_CONTinswap_count()could be deleted: I don't think there ever was aSWAP_HAS_CONT.Yes. We should correct this. Because this should go to a separate patch, would you mind to submit a patch to fix it?
Sure, I'll do that.
Daniel
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
In reply to Huang, YingQuoted 7 lines · Ying
Quoted 4 lines · Daniel Jordan
Review
Quoted 2 lines
(quoted diff) +2
-0+#else +static inline int __swap_duplicate_cluster(swp_entry_t *entry,This doesn't need inline.
Why not? This is just a one line stub.
Forgot to respond to this. The compiler will likely choose to optimize out calls to an empty function like this. Checking, this is indeed what it does in this case on my machine, with or without inline.
By the way, when building without CONFIG_THP_SWAP, we get
linux/mm/swapfile.c:933:13: warning: a??__swap_free_clustera?? defined but not used [-Wunused-function]
static void __swap_free_cluster(struct swap_info_struct *si, unsigned long idx)
^~~~~~~~~~~~~~~~~~~
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
Quoted 7 lines · Daniel Jordan
Quoted 6 lines · Ying
Quoted 4 lines · Daniel Jordan
Review
Quoted 2 lines
(quoted diff) +2
-0+#else +static inline int __swap_duplicate_cluster(swp_entry_t *entry,This doesn't need inline.
Quoted 5 lines
Quoted 1 line
Why not? This is just a one line stub.
Forgot to respond to this. The compiler will likely choose to optimize out calls to an empty function like this. Checking, this is indeed what it does in this case on my machine, with or without inline.
Yes. I believe a decent compiler will inline the function in any way. And it does no harm to keep "inline" too, Yes?
Quoted 5 lines
By the way, when building without
CONFIG_THP_SWAP, we get
linux/mm/swapfile.c:933:13: warning: a??__swap_free_clustera?? defined but not used [-Wunused-function]
static void__swap_free_cluster(struct swap_info_struct *si, unsigned long idx)^~~~~~~~~~~~~~~~~~~
Thanks! I will fix this. Don't know why 0-Day didn't catch this.
Best Regards,
Huang, Ying
Re: [PATCH -mm -V3 03/21] mm, THP, swap: Support PMD swap mapping in swap_duplicate()
Quoted 9 lines · Ying
Quoted 7 lines · Daniel Jordan
Quoted 6 lines · Ying
Quoted 4 lines · Daniel Jordan
Review
Quoted 2 lines
(quoted diff) +2
-0+#else +static inline int __swap_duplicate_cluster(swp_entry_t *entry,This doesn't need inline.
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
Why not? This is just a one line stub.
Forgot to respond to this. The compiler will likely choose to optimize out calls to an empty function like this. Checking, this is indeed what it does in this case on my machine, with or without inline.
Yes. I believe a decent compiler will inline the function in any way. And it does no harm to keep "inline" too, Yes?
Right, it does no harm, it's just a matter of style.
PATCH 4/21 mm, THP, swap: Support PMD swap mapping in swapcache_free_cluster()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
Previously, during swapout, all PMD page mapping will be split and replaced with PTE swap mapping. And when clearing the SWAP_HAS_CACHE flag for the huge swap cluster in swapcache_free_cluster(), the huge swap cluster will be split. Now, during swapout, the PMD page mapping will be changed to PMD swap mapping. So when clearing the SWAP_HAS_CACHE flag, the huge swap cluster will only be split if the PMD swap mapping count is 0. Otherwise, we will keep it as the huge swap cluster. So that we can swapin a THP as a whole later.
--- mm/swapfile.c | 41 ++++++++++++++++++++++++++++++----------- 1 file changed, 30 insertions(+), 11 deletions(-)
mm/swapfile.c +30 -11
@@ -514,6 +514,18 @@ static void dec_cluster_info_page(struct swap_info_struct *p,free_cluster (p, idx); } +#ifdef CONFIG_THP_SWAP +static inline int cluster_swapcount (struct swap_cluster_info *ci) +{ +if (!ci || !cluster_is_huge (ci)) +return 0 ; + +return cluster_count (ci) -SWAPFILE_CLUSTER ; +} +#else +#define cluster_swapcount (ci) 0 +#endif +/* * It's possible scan_swap_map() uses a free cluster in the middle of free * cluster list. Avoiding such abuse to avoid list corruption.
@@ -905,6 +917,7 @@ static void swap_free_cluster(struct swap_info_struct *si, unsigned long idx)struct swap_cluster_info *ci; ci =lock_cluster (si, offset); +memset (si->swap_map + offset,0 ,SWAPFILE_CLUSTER );cluster_set_count_flag (ci,0 ,0 );free_cluster (si, idx);unlock_cluster (ci);
@@ -1288,24 +1301,30 @@ static void swapcache_free_cluster(swp_entry_t entry) ci =lock_cluster (si, offset);VM_BUG_ON (!cluster_is_huge (ci)); +VM_BUG_ON (!is_cluster_offset (offset)); +VM_BUG_ON (cluster_count (ci) <SWAPFILE_CLUSTER ); map = si->swap_map + offset; -for (i =0 ; i <SWAPFILE_CLUSTER ; i++) { - val = map[i]; -VM_BUG_ON (!(val &SWAP_HAS_CACHE )); -if (val ==SWAP_HAS_CACHE ) - free_entries++; +if (!cluster_swapcount (ci)) { +for (i =0 ; i <SWAPFILE_CLUSTER ; i++) { + val = map[i]; +VM_BUG_ON (!(val &SWAP_HAS_CACHE )); +if (val ==SWAP_HAS_CACHE ) + free_entries++; + } +if (free_entries !=SWAPFILE_CLUSTER ) +cluster_clear_huge (ci); }if (!free_entries) { -for (i =0 ; i <SWAPFILE_CLUSTER ; i++) - map[i] &= ~SWAP_HAS_CACHE ; +for (i =0 ; i <SWAPFILE_CLUSTER ; i++) { + val = map[i]; +VM_BUG_ON (!(val &SWAP_HAS_CACHE ) || + val ==SWAP_HAS_CACHE ); + map[i] = val & ~SWAP_HAS_CACHE ; + } } -cluster_clear_huge (ci);unlock_cluster (ci);if (free_entries ==SWAPFILE_CLUSTER ) {spin_lock (&si->lock); - ci =lock_cluster (si, offset); -memset (map,0 ,SWAPFILE_CLUSTER ); -unlock_cluster (ci);mem_cgroup_uncharge_swap (entry,SWAPFILE_CLUSTER );swap_free_cluster (si, idx);spin_unlock (&si->lock);
Signature · 1 line
2.16.1
PATCH 5/21 mm, THP, swap: Support PMD swap mapping in free_swap_and_cache()/swap_free()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
When a PMD swap mapping is removed from a huge swap cluster, for example, unmap a memory range mapped with PMD swap mapping, etc, free_swap_and_cache() will be called to decrease the reference count to the huge swap cluster. free_swap_and_cache() may also free or split the huge swap cluster, and free the corresponding THP in swap cache if necessary. swap_free() is similar, and shares most implementation with free_swap_and_cache(). This patch revises free_swap_and_cache() and swap_free() to implement this.
If the swap cluster has been split already, for example, because of failing to allocate a THP during swapin, we just decrease one from the reference count of all swap slots.
Otherwise, we will decrease one from the reference count of all swap slots and the PMD swap mapping count in cluster_count(). When the corresponding THP isn't in swap cache, if PMD swap mapping count becomes 0, the huge swap cluster will be split, and if all swap count becomes 0, the huge swap cluster will be freed. When the corresponding THP is in swap cache, if every swap_map[offset] == SWAP_HAS_CACHE, we will try to delete the THP from swap cache. Which will cause the THP and the huge swap cluster be freed.
--- arch/s390/mm/pgtable.c | 2 +- include/linux/swap.h | 9 ++-- kernel/power/swap.c | 4 +- mm/madvise.c | 2 +- mm/memory.c | 4 +- mm/shmem.c | 6 +-- mm/swapfile.c | 114 +++++++++++++++++++++++++++++++++++++++++++------ 7 files changed, 116 insertions(+), 25 deletions(-)
arch/s390/mm/pgtable.c +1 -1
@@ -646,7 +646,7 @@ static void ptep_zap_swap_entry(struct mm_struct *mm, swp_entry_t entry)dec_mm_counter (mm,mm_counter (page)); } -free_swap_and_cache (entry); +free_swap_and_cache (entry, false); } void ptep_zap_unused(struct mm_struct *mm, unsigned long addr,
include/linux/swap.h +5 -4
@@ -453,9 +453,9 @@ extern int add_swap_count_continuation(swp_entry_t, gfp_t);extern void swap_shmem_alloc (swp_entry_t );extern int swap_duplicate (swp_entry_t *entry,bool cluster);extern int swapcache_prepare (swp_entry_t entry,bool cluster); -extern void swap_free (swp_entry_t ); +extern void swap_free (swp_entry_t entry,bool cluster);extern void swapcache_free_entries (swp_entry_t *entries,int n); -extern int free_swap_and_cache (swp_entry_t ); +extern int free_swap_and_cache (swp_entry_t entry,bool cluster);extern int swap_type_of (dev_t ,sector_t ,struct block_device **);extern unsigned int count_swap_pages (int ,int );extern sector_t map_swap_page (struct page *,struct block_device **);
@@ -509,7 +509,8 @@ static inline void show_swap_cache_info(void) { } -#define free_swap_and_cache (e) ({(is_migration_entry(e) || is_device_private_entry(e));}) +#define free_swap_and_cache (e, c) \ + ({(is_migration_entry(e) || is_device_private_entry(e)); })#define swapcache_prepare (e, c) \ ({(is_migration_entry(e) || is_device_private_entry(e)); })
@@ -527,7 +528,7 @@ static inline int swap_duplicate(swp_entry_t *swp, bool cluster)return 0 ; } -static inline void swap_free (swp_entry_t swp) +static inline void swap_free (swp_entry_t swp,bool cluster) { }
kernel/power/swap.c +2 -2
@@ -182,7 +182,7 @@ sector_t alloc_swapdev_block(int swap) offset =swp_offset (get_swap_page_of_type (swap));if (offset) {if (swsusp_extents_insert (offset)) -swap_free (swp_entry (swap, offset)); +swap_free (swp_entry (swap, offset), false);else return swapdev_block (swap, offset); }
@@ -206,7 +206,7 @@ void free_all_swap_pages(int swap) ext = rb_entry(node, struct swsusp_extent, node);rb_erase (node, &swsusp_extents);for (offset = ext->start; offset <= ext->end; offset++) -swap_free (swp_entry (swap, offset)); +swap_free (swp_entry (swap, offset), false);kfree (ext); }
mm/madvise.c +1 -1
@@ -349,7 +349,7 @@ static int madvise_free_pte_range(pmd_t *pmd, unsigned long addr,if (non_swap_entry (entry))continue ; nr_swap--; -free_swap_and_cache (entry); +free_swap_and_cache (entry, false);pte_clear_not_present_full (mm, addr, pte, tlb->fullmm);continue ; }
mm/memory.c +2 -2
@@ -1376,7 +1376,7 @@ static unsigned long zap_pte_range(struct mmu_gather *tlb, page =migration_entry_to_page (entry); rss[mm_counter (page)]--; } -if (unlikely (!free_swap_and_cache (entry))) +if (unlikely (!free_swap_and_cache (entry, false)))print_bad_pte (vma, addr, ptent,NULL );pte_clear_not_present_full (mm, addr, pte, tlb->fullmm); }while (pte++, addr +=PAGE_SIZE , addr != end);
@@ -3060,7 +3060,7 @@ int do_swap_page(struct vm_fault *vmf) }set_pte_at (vma->vm_mm, vmf->address, vmf->pte, pte); -swap_free (entry); +swap_free (entry, false);if (mem_cgroup_swap_full (page) || (vma->vm_flags &VM_LOCKED ) ||PageMlocked (page))try_to_free_swap (page);
mm/shmem.c +3 -3
@@ -676,7 +676,7 @@ static int shmem_free_swap(struct address_space *mapping,xa_unlock_irq (&mapping->i_pages);if (old != radswap)return -ENOENT ; -free_swap_and_cache (radix_to_swp_entry (radswap)); +free_swap_and_cache (radix_to_swp_entry (radswap), false);return 0 ; }
@@ -1211,7 +1211,7 @@ static int shmem_unuse_inode(struct shmem_inode_info *info,spin_lock_irq (&info->lock); info->swapped--;spin_unlock_irq (&info->lock); -swap_free (swap); +swap_free (swap, false); } }return error;
@@ -1750,7 +1750,7 @@ static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,delete_from_swap_cache (page);set_page_dirty (page); -swap_free (swap); +swap_free (swap, false); }else {if (vma &&userfaultfd_missing (vma)) {
mm/swapfile.c +102 -12
200 lines not on this page · raw message
Signature · 1 line
2.16.1
PATCH 6/21 mm, THP, swap: Support PMD swap mapping when splitting huge PMD
In reply to Huang, YingFrom: Huang Ying <[email protected]>
A huge PMD need to be split when zap a part of the PMD mapping etc. If the PMD mapping is a swap mapping, we need to split it too. This patch implemented the support for this. This is similar as splitting the PMD page mapping, except we need to decrease the PMD swap mapping count for the huge swap cluster too. If the PMD swap mapping count becomes 0, the huge swap cluster will be split.
Notice: is_huge_zero_pmd() and pmd_page() doesn't work well with swap PMD, so pmd_present() check is called before them.
--- include/linux/swap.h | 6 ++++++ mm/huge_memory.c | 58 +++++++++++++++++++++++++++++++++++++++++++++++----- mm/swapfile.c | 28 +++++++++++++++++++++++++ 3 files changed, 87 insertions(+), 5 deletions(-)
include/linux/swap.h +6 -0
@@ -618,11 +618,17 @@ static inline swp_entry_t get_swap_page(struct page *page)#ifdef CONFIG_THP_SWAP extern int split_swap_cluster (swp_entry_t entry); +extern int split_swap_cluster_map (swp_entry_t entry);#else static inline int split_swap_cluster (swp_entry_t entry) {return 0 ; } + +static inline int split_swap_cluster_map (swp_entry_t entry) +{ +return 0 ; +}#endif #ifdef CONFIG_MEMCG
mm/huge_memory.c +53 -5
94 lines not on this page · raw message
mm/swapfile.c +28 -0
@@ -4046,6 +4046,34 @@ static void free_swap_count_continuations(struct swap_info_struct *si) } } +#ifdef CONFIG_THP_SWAP +/* The corresponding page table shouldn't be changed under us */ +int split_swap_cluster_map (swp_entry_t entry) +{ +struct swap_info_struct *si; +struct swap_cluster_info *ci; +unsigned long offset =swp_offset (entry); + +VM_BUG_ON (!is_cluster_offset (offset)); + si =_swap_info_get (entry); +if (!si) +return -EBUSY ; + ci =lock_cluster (si, offset); +/* The swap cluster has been split by someone else */ +if (!cluster_is_huge (ci)) + goto out; +cluster_set_count (ci,cluster_count (ci) -1 ); +VM_BUG_ON (cluster_count (ci) <SWAPFILE_CLUSTER ); +if (cluster_count (ci) ==SWAPFILE_CLUSTER && + !(si->swap_map[offset] &SWAP_HAS_CACHE )) +cluster_clear_huge (ci); + +out: +unlock_cluster (ci); +return 0 ; +} +#endif +static int __init swapfile_init (void ) {int nid;
Signature · 1 line
2.16.1
PATCH 7/21 mm, THP, swap: Support PMD swap mapping in split_swap_cluster()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
When splitting a THP in swap cache or failing to allocate a THP when swapin a huge swap cluster, the huge swap cluster will be split. In addition to clear the huge flag of the swap cluster, the PMD swap mapping count recorded in cluster_count() will be set to 0. But we will not touch PMD swap mappings themselves, because it is hard to find them all sometimes. When the PMD swap mappings are operated later, it will be found that the huge swap cluster has been split and the PMD swap mappings will be split at that time.
Unless splitting a THP in swap cache (specified via "force" parameter), split_swap_cluster() will return -EEXIST if there is SWAP_HAS_CACHE flag in swap_map[offset]. Because this indicates there is a THP corresponds to this huge swap cluster, and it isn't desired to split the THP.
When splitting a THP in swap cache, the position to call split_swap_cluster() is changed to before unlocking sub-pages. So that all sub-pages will be kept locked from the THP has been split to the huge swap cluster is split. This makes the code much easier to be reasoned.
--- include/linux/swap.h | 4 ++-- mm/huge_memory.c | 18 ++++++++++++------ mm/swapfile.c | 45 ++++++++++++++++++++++++++++++--------------- 3 files changed, 44 insertions(+), 23 deletions(-)
include/linux/swap.h +2 -2
@@ -617,10 +617,10 @@ static inline swp_entry_t get_swap_page(struct page *page)#endif /* CONFIG_SWAP */ #ifdef CONFIG_THP_SWAP -extern int split_swap_cluster (swp_entry_t entry); +extern int split_swap_cluster (swp_entry_t entry,bool force);extern int split_swap_cluster_map (swp_entry_t entry);#else -static inline int split_swap_cluster (swp_entry_t entry) +static inline int split_swap_cluster (swp_entry_t entry,bool force) {return 0 ; }
mm/huge_memory.c +12 -6
@@ -2502,6 +2502,17 @@ static void __split_huge_page(struct page *page, struct list_head *list,unfreeze_page (head); +/* +* Split swap cluster before unlocking sub-pages. So all +* sub-pages will be kept locked from THP has been split to +* swap cluster is split. +*/ +if (PageSwapCache (head)) { +swp_entry_t entry = { .val =page_private (head) }; + +split_swap_cluster (entry, true); + } +for (i =0 ; i <HPAGE_PMD_NR ; i++) {struct page *subpage = head + i;if (subpage == page)
@@ -2728,12 +2739,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)__dec_node_page_state (page,NR_SHMEM_THPS );spin_unlock (&pgdata->split_queue_lock);__split_huge_page (page, list, flags); -if (PageSwapCache (head)) { -swp_entry_t entry = { .val =page_private (head) }; - - ret =split_swap_cluster (entry); - }else - ret =0 ; + ret =0 ; }else {if (IS_ENABLED (CONFIG_DEBUG_VM ) && mapcount) { pr_alert("total_mapcount: %u, page_count(): %u\n",
mm/swapfile.c +30 -15
57 lines not on this page · raw message
Signature · 1 line
2.16.1
PATCH 8/21 mm, THP, swap: Support to read a huge swap cluster for swapin a THP
In reply to Huang, YingFrom: Huang Ying <[email protected]>
To swapin a THP as a whole, we need to read a huge swap cluster from the swap device. This patch revised the __read_swap_cache_async() and its callers and callees to support this. If __read_swap_cache_async() find the swap cluster of the specified swap entry is huge, it will try to allocate a THP, add it into the swap cache. So later the contents of the huge swap cluster can be read into the THP.
--- include/linux/huge_mm.h | 38 ++++++++++++++++++++++++ include/linux/swap.h | 4 +-- mm/huge_memory.c | 26 ----------------- mm/swap_state.c | 77 ++++++++++++++++++++++++++++++++++--------------- mm/swapfile.c | 11 ++++--- 5 files changed, 100 insertions(+), 56 deletions(-)
include/linux/huge_mm.h +38 -0
@@ -250,6 +250,39 @@ static inline bool thp_migration_supported(void) return IS_ENABLED(CONFIG_ARCH_ENABLE_THP_MIGRATION); } +/* +* always: directly stall for all thp allocations +* defer: wake kswapd and fail if not immediately available +* defer+madvise: wake kswapd and directly stall for MADV_HUGEPAGE, otherwise +* fail if not immediately available +* madvise: directly stall for MADV_HUGEPAGE, otherwise fail if not immediately +* available +* never: never stall for any thp allocation +*/ +static inline gfp_t alloc_hugepage_direct_gfpmask (struct vm_area_struct *vma) +{ +bool vma_madvised; + +if (!vma) +return GFP_TRANSHUGE_LIGHT ; + vma_madvised = !!(vma->vm_flags &VM_HUGEPAGE ); +if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG , + &transparent_hugepage_flags)) +return GFP_TRANSHUGE | (vma_madvised ?0 : __GFP_NORETRY); +if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG , + &transparent_hugepage_flags)) +return GFP_TRANSHUGE_LIGHT | __GFP_KSWAPD_RECLAIM; +if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG , + &transparent_hugepage_flags)) +return GFP_TRANSHUGE_LIGHT | + (vma_madvised ? __GFP_DIRECT_RECLAIM : + __GFP_KSWAPD_RECLAIM); +if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG , + &transparent_hugepage_flags)) +return GFP_TRANSHUGE_LIGHT | + (vma_madvised ? __GFP_DIRECT_RECLAIM :0 ); +return GFP_TRANSHUGE_LIGHT ; +}#else /* CONFIG_TRANSPARENT_HUGEPAGE */ #define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; })#define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; })
@@ -362,6 +395,11 @@ static inline bool thp_migration_supported(void) {return false; } + +static inline gfp_t alloc_hugepage_direct_gfpmask (struct vm_area_struct *vma) +{ +return 0 ; +}#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ #endif /* _LINUX_HUGE_MM_H */
include/linux/swap.h +2 -2
@@ -462,7 +462,7 @@ 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 (swp_entry_t entry); -extern int __swp_swapcount (swp_entry_t entry); +extern int __swp_swapcount (swp_entry_t entry,bool *huge_cluster);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);
@@ -589,7 +589,7 @@ static inline int __swap_count(swp_entry_t entry)return 0 ; } -static inline int __swp_swapcount (swp_entry_t entry) +static inline int __swp_swapcount (swp_entry_t entry,bool *huge_cluster) {return 0 ; }
mm/huge_memory.c +0 -26
@@ -620,32 +620,6 @@ static int __do_huge_pmd_anonymous_page(struct vm_fault *vmf, struct page *page, } -/* -* always: directly stall for all thp allocations -* defer: wake kswapd and fail if not immediately available -* defer+madvise: wake kswapd and directly stall for MADV_HUGEPAGE, otherwise -* fail if not immediately available -* madvise: directly stall for MADV_HUGEPAGE, otherwise fail if not immediately -* available -* never: never stall for any thp allocation -*/ -static inline gfp_t alloc_hugepage_direct_gfpmask (struct vm_area_struct *vma) -{ -const bool vma_madvised = !!(vma->vm_flags &VM_HUGEPAGE ); - -if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG , &transparent_hugepage_flags)) -return GFP_TRANSHUGE | (vma_madvised ?0 : __GFP_NORETRY); -if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG , &transparent_hugepage_flags)) -return GFP_TRANSHUGE_LIGHT | __GFP_KSWAPD_RECLAIM; -if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG , &transparent_hugepage_flags)) -return GFP_TRANSHUGE_LIGHT | (vma_madvised ? __GFP_DIRECT_RECLAIM : - __GFP_KSWAPD_RECLAIM); -if (test_bit (TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG , &transparent_hugepage_flags)) -return GFP_TRANSHUGE_LIGHT | (vma_madvised ? __GFP_DIRECT_RECLAIM : -0 ); -return GFP_TRANSHUGE_LIGHT ; -} -/* Caller must hold page table lock. */ static bool set_huge_zero_page(pgtable_t pgtable, struct mm_struct *mm, struct vm_area_struct *vma, unsigned long haddr, pmd_t *pmd,
mm/swap_state.c +53 -24
142 lines not on this page · raw message
mm/swapfile.c +7 -4
@@ -1501,7 +1501,8 @@ int __swap_count(swp_entry_t entry)return count; } -static int swap_swapcount (struct swap_info_struct *si,swp_entry_t entry) +static int swap_swapcount (struct swap_info_struct *si,swp_entry_t entry, +bool *huge_cluster) {int count =0 ;pgoff_t offset =swp_offset (entry);
@@ -1509,6 +1510,8 @@ static int swap_swapcount(struct swap_info_struct *si, swp_entry_t entry) ci =lock_cluster_or_swap_info (si, offset); count =swap_count (si->swap_map[offset]); +if (huge_cluster && ci) + *huge_cluster =cluster_is_huge (ci);unlock_cluster_or_swap_info (si, ci);return count; }
@@ -1518,14 +1521,14 @@ static int swap_swapcount(struct swap_info_struct *si, swp_entry_t entry)* This does not give an exact answer when swap count is continued, * but does include the high COUNT_CONTINUED flag to allow for that. */ -int __swp_swapcount (swp_entry_t entry) +int __swp_swapcount (swp_entry_t entry,bool *huge_cluster) {int count =0 ;struct swap_info_struct *si; si =get_swap_device (entry);if (si) { - count =swap_swapcount (si, entry); + count =swap_swapcount (si, entry, huge_cluster);put_swap_device (si); }return count;
@@ -1685,7 +1688,7 @@ static int page_trans_huge_map_swapcount(struct page *page, int *total_mapcount,return map_swapcount; }#else -#define swap_page_trans_huge_swapped (si, entry) swap_swapcount(si, entry) +#define swap_page_trans_huge_swapped (si, entry) swap_swapcount(si, entry, NULL)#define page_swapped (page) (page_swapcount(page) != 0) static int page_trans_huge_map_swapcount(struct page *page, int *total_mapcount,
Signature · 1 line
2.16.1
PATCH 9/21 mm, THP, swap: Swapin a THP as a whole
In reply to Huang, YingFrom: Huang Ying <[email protected]>
With this patch, when page fault handler find a PMD swap mapping, it will swap in a THP as a whole. This avoids the overhead of splitting/collapsing before/after the THP swapping. And improves the swap performance greatly for reduced page fault count etc.
do_huge_pmd_swap_page() is added in the patch to implement this. It is similar to do_swap_page() for normal page swapin.
If failing to allocate a THP, the huge swap cluster and the PMD swap mapping will be split to fallback to normal page swapin.
If the huge swap cluster has been split already, the PMD swap mapping will be split to fallback to normal page swapin.
--- include/linux/huge_mm.h | 9 +++ include/linux/swap.h | 9 +++ mm/huge_memory.c | 170 ++++++++++++++++++++++++++++++++++++++++++++++++ mm/memory.c | 16 +++-- 4 files changed, 198 insertions(+), 6 deletions(-)
include/linux/huge_mm.h +9 -0
@@ -402,4 +402,13 @@ static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma) }#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ +#ifdef CONFIG_THP_SWAP +extern int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd); +#else /* CONFIG_THP_SWAP */ +static inline int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd) +{ +return 0 ; +} +#endif /* CONFIG_THP_SWAP */ +#endif /* _LINUX_HUGE_MM_H */
include/linux/swap.h +9 -0
@@ -560,6 +560,15 @@ static inline struct page *lookup_swap_cache(swp_entry_t swp,return NULL ; } +static inline struct page *read_swap_cache_async (swp_entry_t swp, +gfp_t gft_mask, +struct vm_area_struct *vma, +unsigned long addr, +bool do_poll) +{ +return NULL ; +} +static inline int add_to_swap (struct page *page) {return 0 ;
mm/huge_memory.c +170 -0
182 lines not on this page · raw message
mm/memory.c +10 -6
@@ -4073,13 +4073,17 @@ static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,barrier ();if (unlikely (is_swap_pmd (orig_pmd))) { -VM_BUG_ON (thp_migration_supported () && - !is_pmd_migration_entry (orig_pmd)); -if (is_pmd_migration_entry (orig_pmd)) +if (thp_migration_supported () && +is_pmd_migration_entry (orig_pmd)) {pmd_migration_entry_wait (mm, vmf.pmd); -return 0 ; - } -if (pmd_trans_huge (orig_pmd) ||pmd_devmap (orig_pmd)) { +return 0 ; + }else if (thp_swap_supported ()) { + ret =do_huge_pmd_swap_page (&vmf, orig_pmd); +if (!(ret &VM_FAULT_FALLBACK )) +return ret; + }else +VM_BUG_ON (1 ); + }else if (pmd_trans_huge (orig_pmd) ||pmd_devmap (orig_pmd)) {if (pmd_protnone (orig_pmd) &&vma_is_accessible (vma))return do_huge_pmd_numa_page (&vmf, orig_pmd);
Signature · 1 line
2.16.1
PATCH 10/21 mm, THP, swap: Support to count THP swapin and its fallback
In reply to Huang, YingFrom: Huang Ying <[email protected]>
2 new /proc/vmstat fields are added, "thp_swapin" and "thp_swapin_fallback" to count swapin a THP from swap device as a whole and fallback to normal page swapin.
--- Documentation/vm/transhuge.rst | 10 +++++++++- include/linux/vm_event_item.h | 2 ++ mm/huge_memory.c | 4 +++- mm/page_io.c | 15 ++++++++++++--- mm/vmstat.c | 2 ++ 5 files changed, 28 insertions(+), 5 deletions(-)
Documentation/vm/transhuge.rst +9 -1
@@ -360,10 +360,18 @@ thp_swpout piece without splitting. thp_swpout_fallback - is incremented if a huge page has to be split before swapout. + is incremented if a huge page is split before swapout. Usually because failed to allocate some continuous swap space for the huge page. +thp_swpin + is incremented every time a huge page is swapin in one piece + without splitting. + +thp_swpin_fallback + is incremented if a huge page is split during swapin. Usually + because failed to allocate a huge page. + As the system ages, allocating huge pages may be expensive as the system uses memory compaction to copy data around memory to free a huge page for use. There are some counters in ``/proc/vmstat`` to help
include/linux/vm_event_item.h +2 -0
@@ -88,6 +88,8 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,THP_ZERO_PAGE_ALLOC_FAILED ,THP_SWPOUT ,THP_SWPOUT_FALLBACK , +THP_SWPIN , +THP_SWPIN_FALLBACK , #endif #ifdef CONFIG_MEMORY_BALLOON BALLOON_INFLATE,
mm/huge_memory.c +3 -1
@@ -1664,8 +1664,10 @@ int do_huge_pmd_swap_page(struct vm_fault *vmf, pmd_t orig_pmd)/* swapoff occurs under us */ }else if (ret == -EINVAL ) ret =0 ; -else +else { +count_vm_event (THP_SWPIN_FALLBACK ); goto fallback; + } }delayacct_clear_flag (DELAYACCT_PF_SWAPIN ); goto out;
mm/page_io.c +12 -3
@@ -347,6 +347,15 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,return ret; } +static inline void count_swpin_vm_event (struct page *page) +{ +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +if (unlikely (PageTransHuge (page))) +count_vm_event (THP_SWPIN ); +#endif +count_vm_events (PSWPIN ,hpage_nr_pages (page)); +} +int swap_readpage (struct page *page,bool synchronous) {struct bio *bio;
@@ -370,7 +379,7 @@ int swap_readpage(struct page *page, bool synchronous) ret = mapping->a_ops->readpage (swap_file, page);if (!ret) -count_vm_event (PSWPIN ); +count_swpin_vm_event (page);return ret; }
@@ -381,7 +390,7 @@ int swap_readpage(struct page *page, bool synchronous)unlock_page (page); } -count_vm_event (PSWPIN ); +count_swpin_vm_event (page);return 0 ; }
@@ -400,7 +409,7 @@ int swap_readpage(struct page *page, bool synchronous)get_task_struct (current); bio->bi_private = current;bio_set_op_attrs (bio,REQ_OP_READ ,0 ); -count_vm_event (PSWPIN ); +count_swpin_vm_event (page);bio_get (bio); qc =submit_bio (bio);while (synchronous) {
mm/vmstat.c +2 -0
@@ -1263,6 +1263,8 @@ const char * const vmstat_text[] = {"thp_zero_page_alloc_failed" ,"thp_swpout" ,"thp_swpout_fallback" , +"thp_swpin" , +"thp_swpin_fallback" , #endif #ifdef CONFIG_MEMORY_BALLOON "balloon_inflate",
Signature · 1 line
2.16.1
PATCH 11/21 mm, THP, swap: Add sysfs interface to configure THP swapin
In reply to Huang, YingFrom: Huang Ying <[email protected]>
Swapin a THP as a whole isn't desirable at some situations. For example, for random access pattern, swapin a THP as a whole will inflate the reading greatly. So a sysfs interface:/sys/kernel/mm/transparent_hugepage/swapin_enabled is added to configure it. Three options as follow are provided,
- always: THP swapin will be enabled always
- madvise: THP swapin will be enabled only for VMA with VM_HUGEPAGE flag set.
- never: THP swapin will be disabled always
The default configuration is: madvise.
During page fault, if a PMD swap mapping is found and THP swapin is disabled, the huge swap cluster and the PMD swap mapping will be split and fallback to normal page swapin.
--- Documentation/vm/transhuge.rst | 21 ++++++++++ include/linux/huge_mm.h | 31 +++++++++++++++ mm/huge_memory.c | 89 +++++++++++++++++++++++++++++++++--------- 3 files changed, 123 insertions(+), 18 deletions(-)
Documentation/vm/transhuge.rst +21 -0
@@ -163,6 +163,27 @@ Some userspace (such as a test program, or an optimized memory allocation cat /sys/kernel/mm/transparent_hugepage/hpage_pmd_size +Transparent hugepage may be swapout and swapin in one piece without +splitting. This will improve the utility of transparent hugepage but +inflate the read/write too. So whether to enable swapin transparent +hugepage in one piece can be configured as follow. + + echo always >/sys/kernel/mm/transparent_hugepage/swapin_enabled + echo madvise >/sys/kernel/mm/transparent_hugepage/swapin_enabled + echo never >/sys/kernel/mm/transparent_hugepage/swapin_enabled + +always + Attempt to allocate a transparent huge page and read it from + swap space in one piece every time. + +never + Always split the swap space and PMD swap mapping and swapin + the fault normal page during swapin. + +madvise + Only swapin the transparent huge page in one piece for + MADV_HUGEPAGE madvise regions. + khugepaged will be automatically started when transparent_hugepage/enabled is set to "always" or "madvise, and it'll be automatically shutdown if it's set to "never".
include/linux/huge_mm.h +31 -0
@@ -62,6 +62,8 @@ enum transparent_hugepage_flag {#ifdef CONFIG_DEBUG_VM TRANSPARENT_HUGEPAGE_DEBUG_COW_FLAG , #endif +TRANSPARENT_HUGEPAGE_SWAPIN_FLAG , + TRANSPARENT_HUGEPAGE_SWAPIN_REQ_MADV_FLAG, };struct kobject ;
@@ -404,11 +406,40 @@ static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma)#ifdef CONFIG_THP_SWAP extern int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd); + +static inline bool transparent_hugepage_swapin_enabled ( +struct vm_area_struct *vma) +{ +if (vma->vm_flags &VM_NOHUGEPAGE ) +return false; + +if (is_vma_temporary_stack (vma)) +return false; + +if (test_bit (MMF_DISABLE_THP , &vma->vm_mm->flags)) +return false; + +if (transparent_hugepage_flags & + (1 <<TRANSPARENT_HUGEPAGE_SWAPIN_FLAG )) +return true; + +if (transparent_hugepage_flags & + (1 <<TRANSPARENT_HUGEPAGE_SWAPIN_REQ_MADV_FLAG )) +return !!(vma->vm_flags &VM_HUGEPAGE ); + +return false; +}#else /* CONFIG_THP_SWAP */ static inline int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd) {return 0 ; } + +static inline bool transparent_hugepage_swapin_enabled ( +struct vm_area_struct *vma) +{ +return false; +}#endif /* CONFIG_THP_SWAP */ #endif /* _LINUX_HUGE_MM_H */
mm/huge_memory.c +71 -18
125 lines not on this page · raw message
Signature · 1 line
2.16.1
PATCH 12/21 mm, THP, swap: Support PMD swap mapping in swapoff
In reply to Huang, YingFrom: Huang Ying <[email protected]>
During swapoff, for a huge swap cluster, we need to allocate a THP, read its contents into the THP and unuse the PMD and PTE swap mappings to it. If failed to allocate a THP, the huge swap cluster will be split.
During unuse, if it is found that the swap cluster mapped by a PMD swap mapping is split already, we will split the PMD swap mapping and unuse the PTEs.
--- include/asm-generic/pgtable.h | 15 ++------ include/linux/huge_mm.h | 8 ++++ mm/huge_memory.c | 4 +- mm/swapfile.c | 86 ++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 98 insertions(+), 15 deletions(-)
include/asm-generic/pgtable.h +3 -12
@@ -931,22 +931,13 @@ static inline int pmd_none_or_trans_huge_or_clear_bad(pmd_t *pmd)barrier ();#endif /* -* !pmd_present() checks for pmd migration entries -* -* The complete check uses is_pmd_migration_entry() in linux/swapops.h -* But using that requires moving current function and pmd_trans_unstable() -* to linux/swapops.h to resovle dependency, which is too much code move. -* -* !pmd_present() is equivalent to is_pmd_migration_entry() currently, -* because !pmd_present() pages can only be under migration not swapped -* out. -* -* pmd_none() is preseved for future condition checks on pmd migration +* pmd_none() is preseved for future condition checks on pmd swap * entries and not confusing with this function name, although it is * redundant with !pmd_present(). */ if (pmd_none (pmdval) ||pmd_trans_huge (pmdval) || - (IS_ENABLED (CONFIG_ARCH_ENABLE_THP_MIGRATION ) && !pmd_present (pmdval))) + ((IS_ENABLED (CONFIG_ARCH_ENABLE_THP_MIGRATION ) || +IS_ENABLED (CONFIG_THP_SWAP )) && !pmd_present (pmdval)))return 1 ;if (unlikely (pmd_bad (pmdval))) {pmd_clear_bad (pmd);
include/linux/huge_mm.h +8 -0
@@ -405,6 +405,8 @@ static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma)#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ #ifdef CONFIG_THP_SWAP +extern int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd, +unsigned long address,pmd_t orig_pmd);extern int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd); static inline bool transparent_hugepage_swapin_enabled(
@@ -430,6 +432,12 @@ static inline bool transparent_hugepage_swapin_enabled( return false; }#else /* CONFIG_THP_SWAP */ +static inline int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd, +unsigned long address,pmd_t orig_pmd) +{ +return 0 ; +} +static inline int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd) {return 0 ;
mm/huge_memory.c +2 -2
@@ -1663,8 +1663,8 @@ static void __split_huge_swap_pmd(struct vm_area_struct *vma,pmd_populate (mm, pmd, pgtable); } -static int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd, -unsigned long address,pmd_t orig_pmd) +int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd, +unsigned long address,pmd_t orig_pmd) {struct mm_struct *mm = vma->vm_mm;spinlock_t *ptl;
mm/swapfile.c +85 -1
134 lines not on this page · raw message
Signature · 1 line
2.16.1
PATCH 13/21 mm, THP, swap: Support PMD swap mapping in madvise_free()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
When madvise_free() found a PMD swap mapping, if only part of the huge swap cluster is operated on, the PMD swap mapping will be split and fallback to PTE swap mapping processing. Otherwise, if all huge swap cluster is operated on, free_swap_and_cache() will be called to decrease the PMD swap mapping count and probably free the swap space and the THP in swap cache too.
--- mm/huge_memory.c | 50 +++++++++++++++++++++++++++++++++++--------------- mm/madvise.c | 2 +- 2 files changed, 36 insertions(+), 16 deletions(-)
mm/huge_memory.c +35 -15
@@ -1842,6 +1842,15 @@ static inline void __split_huge_swap_pmd(struct vm_area_struct *vma, }#endif +static inline void zap_deposited_table (struct mm_struct *mm,pmd_t *pmd) +{ +pgtable_t pgtable; + + pgtable =pgtable_trans_huge_withdraw (mm, pmd); +pte_free (mm, pgtable); +mm_dec_nr_ptes (mm); +} +/* * Return true if we do MADV_FREE successfully on entire pmd page. * Otherwise, return false.
@@ -1862,15 +1871,35 @@ bool madvise_free_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma, goto out_unlocked; orig_pmd = *pmd; -if (is_huge_zero_pmd (orig_pmd)) - goto out; -if (unlikely (!pmd_present (orig_pmd))) { -VM_BUG_ON (thp_migration_supported () && - !is_pmd_migration_entry (orig_pmd)); - goto out; +swp_entry_t entry =pmd_to_swp_entry (orig_pmd); + +if (is_migration_entry (entry)) { +VM_BUG_ON (!thp_migration_supported ()); + goto out; + }else if (thp_swap_supported () && !non_swap_entry (entry)) { +/* If part of THP is discarded */ +if (next - addr !=HPAGE_PMD_SIZE ) { +unsigned long haddr = addr &HPAGE_PMD_MASK ; + +__split_huge_swap_pmd (vma, haddr, pmd); + goto out; + } +free_swap_and_cache (entry, true); +pmd_clear (pmd); +zap_deposited_table (mm, pmd); +if (current->mm == mm) +sync_mm_rss (mm); +add_mm_counter (mm,MM_SWAPENTS , -HPAGE_PMD_NR ); + ret = true; + goto out; + }else +VM_BUG_ON (1 ); } +if (is_huge_zero_pmd (orig_pmd)) + goto out; + page =pmd_page (orig_pmd);/* * If other processes are mapping this page, we couldn't discard
@@ -1916,15 +1945,6 @@ bool madvise_free_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,return ret; } -static inline void zap_deposited_table (struct mm_struct *mm,pmd_t *pmd) -{ -pgtable_t pgtable; - - pgtable =pgtable_trans_huge_withdraw (mm, pmd); -pte_free (mm, pgtable); -mm_dec_nr_ptes (mm); -} -int zap_huge_pmd (struct mmu_gather *tlb,struct vm_area_struct *vma,pmd_t *pmd,unsigned long addr) {
mm/madvise.c +1 -1
@@ -321,7 +321,7 @@ static int madvise_free_pte_range(pmd_t *pmd, unsigned long addr,unsigned long next; next =pmd_addr_end (addr, end); -if (pmd_trans_huge (*pmd)) +if (pmd_trans_huge (*pmd) ||is_swap_pmd (*pmd))if (madvise_free_huge_pmd (tlb, vma, pmd, addr, next)) goto next;
Signature · 1 line
2.16.1
PATCH 14/21 mm, cgroup, THP, swap: Support to move swap account for PMD swap mapping
In reply to Huang, YingFrom: Huang Ying <[email protected]>
Previously the huge swap cluster will be split after the THP is swapout. Now, to support to swapin the THP as a whole, the huge swap cluster will not be split after the THP is reclaimed. So in memcg, we need to move the swap account for PMD swap mappings in the process's page table.
When the page table is scanned during moving memcg charge, the PMD swap mapping will be identified. And mem_cgroup_move_swap_account() and its callee is revised to move account for the whole huge swap cluster. If the swap cluster mapped by PMD has been split, the PMD swap mapping will be split and fallback to PTE processing. Because the swap slots of the swap cluster may have been swapin or moved to other cgroup already.
Because there is no way to prevent a huge swap cluster from being split except when it has SWAP_HAS_CACHE flag set. It is possible for the huge swap cluster to be split and the charge for the swap slots inside to be changed, after we check the PMD swap mapping and the huge swap cluster before we commit the charge moving. But the race window is so small, that we will just ignore the race.
--- include/linux/huge_mm.h | 9 +++ include/linux/swap.h | 6 ++ include/linux/swap_cgroup.h | 3 +- mm/huge_memory.c | 12 +--- mm/memcontrol.c | 138 +++++++++++++++++++++++++++++++++++--------- mm/swap_cgroup.c | 45 ++++++++++++--- mm/swapfile.c | 12 ++++ 7 files changed, 180 insertions(+), 45 deletions(-)
include/linux/huge_mm.h +9 -0
@@ -405,6 +405,9 @@ static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma)#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ #ifdef CONFIG_THP_SWAP +extern void __split_huge_swap_pmd (struct vm_area_struct *vma, +unsigned long haddr, +pmd_t *pmd);extern int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd,unsigned long address,pmd_t orig_pmd);extern int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd);
@@ -432,6 +435,12 @@ static inline bool transparent_hugepage_swapin_enabled( return false; }#else /* CONFIG_THP_SWAP */ +static inline void __split_huge_swap_pmd (struct vm_area_struct *vma, +unsigned long haddr, +pmd_t *pmd) +{ +} +static inline int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd,unsigned long address,pmd_t orig_pmd) {
include/linux/swap.h +6 -0
@@ -628,6 +628,7 @@ static inline swp_entry_t get_swap_page(struct page *page)#ifdef CONFIG_THP_SWAP extern int split_swap_cluster (swp_entry_t entry,bool force);extern int split_swap_cluster_map (swp_entry_t entry); +extern bool in_huge_swap_cluster (swp_entry_t entry);#else static inline int split_swap_cluster (swp_entry_t entry,bool force) {
@@ -638,6 +639,11 @@ static inline int split_swap_cluster_map(swp_entry_t entry) {return 0 ; } + +static inline bool in_huge_swap_cluster (swp_entry_t entry) +{ +return false; +}#endif #ifdef CONFIG_MEMCG
include/linux/swap_cgroup.h +2 -1
@@ -7,7 +7,8 @@#ifdef CONFIG_MEMCG_SWAP extern unsigned short swap_cgroup_cmpxchg (swp_entry_t ent, -unsigned short old,unsigned short new); +unsigned short old,unsigned short new, +unsigned int nr_ents);extern unsigned short swap_cgroup_record (swp_entry_t ent,unsigned short id,unsigned int nr_ents);extern unsigned short lookup_swap_cgroup_id (swp_entry_t ent);
mm/huge_memory.c +3 -9
@@ -1630,9 +1630,9 @@ int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t pmd) }#ifdef CONFIG_THP_SWAP -static void __split_huge_swap_pmd (struct vm_area_struct *vma, -unsigned long haddr, -pmd_t *pmd) +void __split_huge_swap_pmd (struct vm_area_struct *vma, +unsigned long haddr, +pmd_t *pmd) {struct mm_struct *mm = vma->vm_mm;pgtable_t pgtable;
@@ -1834,12 +1834,6 @@ int do_huge_pmd_swap_page(struct vm_fault *vmf, pmd_t orig_pmd)count_vm_event (THP_SWPIN_FALLBACK ); goto fallback; } -#else -static inline void __split_huge_swap_pmd (struct vm_area_struct *vma, -unsigned long haddr, -pmd_t *pmd) -{ -}#endif static inline void zap_deposited_table (struct mm_struct *mm,pmd_t *pmd)
mm/memcontrol.c +111 -27
261 lines not on this page · raw message
mm/swap_cgroup.c +37 -8
66 lines not on this page · raw message
mm/swapfile.c +12 -0
@@ -1687,6 +1687,18 @@ static int page_trans_huge_map_swapcount(struct page *page, int *total_mapcount, return map_swapcount; } + +bool in_huge_swap_cluster (swp_entry_t entry) +{ +struct swap_info_struct *si; +struct swap_cluster_info *ci; + + si =_swap_info_get (entry); +if (!si || !si->cluster_info) +return false; + ci = si->cluster_info +swp_offset (entry) /SWAPFILE_CLUSTER ; +return cluster_is_huge (ci); +}#else #define swap_page_trans_huge_swapped (si, entry) swap_swapcount(si, entry, NULL)#define page_swapped (page) (page_swapcount(page) != 0)
Signature · 1 line
2.16.1
PATCH 15/21 mm, THP, swap: Support to copy PMD swap mapping when fork()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
During fork, the page table need to be copied from parent to child. A PMD swap mapping need to be copied too and the swap reference count need to be increased.
When the huge swap cluster has been split already, we need to split the PMD swap mapping and fallback to PTE copying.
When swap count continuation failed to allocate a page with GFP_ATOMIC, we need to unlock the spinlock and try again with GFP_KERNEL.
--- mm/huge_memory.c | 72 ++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 57 insertions(+), 15 deletions(-)
mm/huge_memory.c +57 -15
@@ -941,6 +941,7 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,if (unlikely (!pgtable)) goto out; +retry: dst_ptl =pmd_lock (dst_mm, dst_pmd); src_ptl =pmd_lockptr (src_mm, src_pmd);spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING );
@@ -948,26 +949,67 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm, ret = -EAGAIN ; pmd = *src_pmd; -#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION if (unlikely (is_swap_pmd (pmd))) {swp_entry_t entry =pmd_to_swp_entry (pmd); -VM_BUG_ON (!is_pmd_migration_entry (pmd)); -if (is_write_migration_entry (entry)) { -make_migration_entry_read (&entry); - pmd =swp_entry_to_pmd (entry); -if (pmd_swp_soft_dirty (*src_pmd)) - pmd =pmd_swp_mksoft_dirty (pmd); -set_pmd_at (src_mm, addr, src_pmd, pmd); +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION +if (is_migration_entry (entry)) { +if (is_write_migration_entry (entry)) { +make_migration_entry_read (&entry); + pmd =swp_entry_to_pmd (entry); +if (pmd_swp_soft_dirty (*src_pmd)) + pmd =pmd_swp_mksoft_dirty (pmd); +set_pmd_at (src_mm, addr, src_pmd, pmd); + } +add_mm_counter (dst_mm,MM_ANONPAGES ,HPAGE_PMD_NR ); +mm_inc_nr_ptes (dst_mm); +pgtable_trans_huge_deposit (dst_mm, dst_pmd, pgtable); +set_pmd_at (dst_mm, addr, dst_pmd, pmd); + ret =0 ; + goto out_unlock; } -add_mm_counter (dst_mm,MM_ANONPAGES ,HPAGE_PMD_NR ); -mm_inc_nr_ptes (dst_mm); -pgtable_trans_huge_deposit (dst_mm, dst_pmd, pgtable); -set_pmd_at (dst_mm, addr, dst_pmd, pmd); - ret =0 ; - goto out_unlock; - }#endif +if (thp_swap_supported () && !non_swap_entry (entry)) { + ret =swap_duplicate (&entry, true); +if (!ret) { +add_mm_counter (dst_mm,MM_SWAPENTS , +HPAGE_PMD_NR ); +mm_inc_nr_ptes (dst_mm); +pgtable_trans_huge_deposit (dst_mm, dst_pmd, + pgtable); +set_pmd_at (dst_mm, addr, dst_pmd, pmd); +/* make sure dst_mm is on swapoff's mmlist. */ +if (unlikely (list_empty (&dst_mm->mmlist))) { +spin_lock (&mmlist_lock); +if (list_empty (&dst_mm->mmlist)) +list_add (&dst_mm->mmlist, + &src_mm->mmlist); +spin_unlock (&mmlist_lock); + } + }else if (ret == -ENOTDIR ) { +/* +* The swap cluster has been split, split the +* pmd map now +*/ +__split_huge_swap_pmd (vma, addr, src_pmd); +pte_free (dst_mm, pgtable); + }else if (ret == -ENOMEM ) { +spin_unlock (src_ptl); +spin_unlock (dst_ptl); + ret =add_swap_count_continuation (entry, +GFP_KERNEL ); +if (ret <0 ) { + ret = -ENOMEM ; +pte_free (dst_mm, pgtable); + goto out; + } + goto retry; + }else +VM_BUG_ON (1 ); + goto out_unlock; + } +VM_BUG_ON (1 ); + }if (unlikely (!pmd_trans_huge (pmd))) {pte_free (dst_mm, pgtable);
Signature · 1 line
2.16.1
PATCH 16/21 mm, THP, swap: Free PMD swap mapping when zap_huge_pmd()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
For a PMD swap mapping, zap_huge_pmd() will clear the PMD and call free_swap_and_cache() to decrease the swap reference count and maybe free or split the huge swap cluster and the THP in swap cache.
--- mm/huge_memory.c | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-)
mm/huge_memory.c +21 -11
@@ -2007,7 +2007,7 @@ int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,spin_unlock (ptl);if (is_huge_zero_pmd (orig_pmd))tlb_remove_page_size (tlb,pmd_page (orig_pmd),HPAGE_PMD_SIZE ); - }else if (is_huge_zero_pmd (orig_pmd)) { + }else if (pmd_present (orig_pmd) &&is_huge_zero_pmd (orig_pmd)) {zap_deposited_table (tlb->mm, pmd);spin_unlock (ptl);tlb_remove_page_size (tlb,pmd_page (orig_pmd),HPAGE_PMD_SIZE );
@@ -2020,17 +2020,27 @@ int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,page_remove_rmap (page, true);VM_BUG_ON_PAGE (page_mapcount (page) <0 , page);VM_BUG_ON_PAGE (!PageHead (page), page); - }else if (thp_migration_supported ()) { -swp_entry_t entry; - -VM_BUG_ON (!is_pmd_migration_entry (orig_pmd)); - entry =pmd_to_swp_entry (orig_pmd); - page =pfn_to_page (swp_offset (entry)); + }else { +swp_entry_t entry =pmd_to_swp_entry (orig_pmd); + +if (thp_migration_supported () && +is_migration_entry (entry)) + page =pfn_to_page (swp_offset (entry)); +else if (thp_swap_supported () && + !non_swap_entry (entry)) +free_swap_and_cache (entry, true); +else { +WARN_ONCE (1 , +"Non present huge pmd without pmd migration or swap enabled!" ); + goto unlock; + } flush_needed =0 ; - }else -WARN_ONCE (1 ,"Non present huge pmd without pmd migration enabled!" ); + } -if (PageAnon (page)) { +if (!page) { +zap_deposited_table (tlb->mm, pmd); +add_mm_counter (tlb->mm,MM_SWAPENTS , -HPAGE_PMD_NR ); + }else if (PageAnon (page)) {zap_deposited_table (tlb->mm, pmd);add_mm_counter (tlb->mm,MM_ANONPAGES , -HPAGE_PMD_NR ); }else {
@@ -2038,7 +2048,7 @@ int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,zap_deposited_table (tlb->mm, pmd);add_mm_counter (tlb->mm,MM_FILEPAGES , -HPAGE_PMD_NR ); } - +unlock:spin_unlock (ptl);if (flush_needed)tlb_remove_page_size (tlb, page,HPAGE_PMD_SIZE );
Signature · 1 line
2.16.1
PATCH 17/21 mm, THP, swap: Support PMD swap mapping for MADV_WILLNEED
In reply to Huang, YingFrom: Huang Ying <[email protected]>
During MADV_WILLNEED, for a PMD swap mapping, if THP swapin is enabled for the VMA, the whole swap cluster will be swapin. Otherwise, the huge swap cluster and the PMD swap mapping will be split and fallback to PTE swap mapping.
--- mm/madvise.c | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-)
mm/madvise.c +24 -2
@@ -196,14 +196,36 @@ static int swapin_walk_pmd_entry(pmd_t *pmd, unsigned long start,pte_t *orig_pte;struct vm_area_struct *vma = walk->private;unsigned long index; +swp_entry_t entry; +struct page *page; +pmd_t pmdval; + + pmdval = *pmd; +if (thp_swap_supported () &&is_swap_pmd (pmdval) && + !is_pmd_migration_entry (pmdval)) { + entry =pmd_to_swp_entry (pmdval); +if (!transparent_hugepage_swapin_enabled (vma)) { +if (!split_swap_cluster (entry, false)) +split_huge_swap_pmd (vma, pmd, start, pmdval); + }else { + page =read_swap_cache_async (entry, +GFP_HIGHUSER_MOVABLE , + vma, start, false); +/* The swap cluster has been split under us */ +if (page) { +if (!PageTransHuge (page)) +split_huge_swap_pmd (vma, pmd, start, + pmdval); +put_page (page); + } + } + }if (pmd_none_or_trans_huge_or_clear_bad (pmd))return 0 ;for (index = start; index != end; index +=PAGE_SIZE ) {pte_t pte; -swp_entry_t entry; -struct page *page;spinlock_t *ptl; orig_pte =pte_offset_map_lock (vma->vm_mm, pmd, start, &ptl);
Signature · 1 line
2.16.1
PATCH 18/21 mm, THP, swap: Support PMD swap mapping in mincore()
In reply to Huang, YingFrom: Huang Ying <[email protected]>
During mincore(), for PMD swap mapping, swap cache will be looked up. If the resulting page isn't compound page, the PMD swap mapping will be split and fallback to PTE swap mapping processing.
--- mm/mincore.c | 37 +++++++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-)
mm/mincore.c +31 -6
@@ -48,7 +48,8 @@ static int mincore_hugetlb(pte_t *pte, unsigned long hmask, unsigned long addr,* and is up to date; i.e. that no page-in operation would be required * at this time if an application were to map and access this page. */ -static unsigned char mincore_page (struct address_space *mapping,pgoff_t pgoff) +static unsigned char mincore_page (struct address_space *mapping,pgoff_t pgoff, +bool *compound) {unsigned char present =0 ;struct page *page;
@@ -86,6 +87,8 @@ static unsigned char mincore_page(struct address_space *mapping, pgoff_t pgoff)#endif if (page) { present =PageUptodate (page); +if (compound) + *compound =PageCompound (page);put_page (page); }
@@ -103,7 +106,8 @@ static int __mincore_unmapped_range(unsigned long addr, unsigned long end, pgoff =linear_page_index (vma, addr);for (i =0 ; i < nr; i++, pgoff++) - vec[i] =mincore_page (vma->vm_file->f_mapping, pgoff); + vec[i] =mincore_page (vma->vm_file->f_mapping, + pgoff,NULL ); }else {for (i =0 ; i < nr; i++) vec[i] =0 ;
@@ -127,14 +131,36 @@ static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,pte_t *ptep;unsigned char *vec = walk->private;int nr = (end - addr) >>PAGE_SHIFT ; +swp_entry_t entry; ptl =pmd_trans_huge_lock (pmd, vma);if (ptl) { -memset (vec,1 , nr); +unsigned char val =1 ; +bool compound; + +if (thp_swap_supported () &&is_swap_pmd (*pmd)) { + entry =pmd_to_swp_entry (*pmd); +if (!non_swap_entry (entry)) { + val =mincore_page (swap_address_space (entry), +swp_offset (entry), + &compound); +/* +* The huge swap cluster has been +* split under us +*/ +if (!compound) { +__split_huge_swap_pmd (vma, addr, pmd); +spin_unlock (ptl); + goto fallback; + } + } + } +memset (vec, val, nr);spin_unlock (ptl); goto out; } +fallback:if (pmd_trans_unstable (pmd)) {__mincore_unmapped_range (addr, end, vma, vec); goto out;
@@ -150,8 +176,7 @@ static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,else if (pte_present (pte)) *vec =1 ;else {/* pte is a swap entry */ -swp_entry_t entry =pte_to_swp_entry (pte); - + entry =pte_to_swp_entry (pte);if (non_swap_entry (entry)) {/* * migration or hwpoison entries are always
@@ -161,7 +186,7 @@ static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end, }else {#ifdef CONFIG_SWAP *vec =mincore_page (swap_address_space (entry), -swp_offset (entry)); +swp_offset (entry),NULL );#else WARN_ON (1 ); *vec =1 ;
Signature · 1 line
2.16.1
PATCH 19/21 mm, THP, swap: Support PMD swap mapping in common path
In reply to Huang, YingFrom: Huang Ying <[email protected]>
Original code is only for PMD migration entry, it is revised to support PMD swap mapping.
--- fs/proc/task_mmu.c | 8 ++++---- mm/gup.c | 34 ++++++++++++++++++++++------------ mm/huge_memory.c | 6 +++--- mm/mempolicy.c | 2 +- 4 files changed, 30 insertions(+), 20 deletions(-)
fs/proc/task_mmu.c +4 -4
@@ -978,7 +978,7 @@ static inline void clear_soft_dirty_pmd(struct vm_area_struct *vma, pmd =pmd_clear_soft_dirty (pmd);set_pmd_at (vma->vm_mm, addr, pmdp, pmd); - }else if (is_migration_entry (pmd_to_swp_entry (pmd))) { + }else if (is_swap_pmd (pmd)) { pmd =pmd_swp_clear_soft_dirty (pmd);set_pmd_at (vma->vm_mm, addr, pmdp, pmd); }
@@ -1309,7 +1309,7 @@ static int pagemap_pmd_range(pmd_t *pmdp, unsigned long addr, unsigned long end, frame =pmd_pfn (pmd) + ((addr & ~PMD_MASK ) >>PAGE_SHIFT ); } -#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION +#if defined(CONFIG_ARCH_ENABLE_THP_MIGRATION ) || defined(CONFIG_THP_SWAP ) else if (is_swap_pmd(pmd)) {swp_entry_t entry =pmd_to_swp_entry (pmd);unsigned long offset;
@@ -1323,8 +1323,8 @@ static int pagemap_pmd_range(pmd_t *pmdp, unsigned long addr, unsigned long end, flags |=PM_SWAP ;if (pmd_swp_soft_dirty (pmd)) flags |=PM_SOFT_DIRTY ; -VM_BUG_ON (!is_pmd_migration_entry (pmd)); - page = migration_entry_to_page(entry); +if (is_pmd_migration_entry (pmd)) + page = migration_entry_to_page(entry); }#endif
mm/gup.c +22 -12
@@ -216,6 +216,7 @@ static struct page *follow_pmd_mask(struct vm_area_struct *vma,spinlock_t *ptl;struct page *page;struct mm_struct *mm = vma->vm_mm; +swp_entry_t entry; pmd =pmd_offset (pudp, address);/*
@@ -243,18 +244,21 @@ static struct page *follow_pmd_mask(struct vm_area_struct *vma,if (!pmd_present (pmdval)) {if (likely (!(flags &FOLL_MIGRATION )))return no_page_table (vma, flags); -VM_BUG_ON (thp_migration_supported () && - !is_pmd_migration_entry (pmdval)); -if (is_pmd_migration_entry (pmdval)) + entry =pmd_to_swp_entry (pmdval); +if (thp_migration_supported () &&is_migration_entry (entry)) {pmd_migration_entry_wait (mm, pmd); - pmdval =READ_ONCE (*pmd); -/* -* MADV_DONTNEED may convert the pmd to null because -* mmap_sem is held in read mode -*/ -if (pmd_none (pmdval)) + pmdval =READ_ONCE (*pmd); +/* +* MADV_DONTNEED may convert the pmd to null because +* mmap_sem is held in read mode +*/ +if (pmd_none (pmdval)) +return no_page_table (vma, flags); + goto retry; + } +if (thp_swap_supported () && !non_swap_entry (entry))return no_page_table (vma, flags); - goto retry; +VM_BUG_ON (1 ); }if (pmd_devmap (pmdval)) { ptl =pmd_lock (mm, pmd);
@@ -276,11 +280,17 @@ static struct page *follow_pmd_mask(struct vm_area_struct *vma,return no_page_table (vma, flags); }if (unlikely (!pmd_present (*pmd))) { + entry =pmd_to_swp_entry (*pmd);spin_unlock (ptl);if (likely (!(flags &FOLL_MIGRATION )))return no_page_table (vma, flags); -pmd_migration_entry_wait (mm, pmd); - goto retry_locked; +if (thp_migration_supported () &&is_migration_entry (entry)) { +pmd_migration_entry_wait (mm, pmd); + goto retry_locked; + } +if (thp_swap_supported () && !non_swap_entry (entry)) +return no_page_table (vma, flags); +VM_BUG_ON (1 ); }if (unlikely (!pmd_trans_huge (*pmd))) {spin_unlock (ptl);
mm/huge_memory.c +3 -3
@@ -2074,7 +2074,7 @@ static inline int pmd_move_must_withdraw(spinlock_t *new_pmd_ptl,static pmd_t move_soft_dirty_pmd (pmd_t pmd) {#ifdef CONFIG_MEM_SOFT_DIRTY -if (unlikely (is_pmd_migration_entry (pmd))) +if (unlikely (is_swap_pmd (pmd))) pmd =pmd_swp_mksoft_dirty (pmd);else if (pmd_present (pmd)) pmd =pmd_mksoft_dirty (pmd);
@@ -2160,11 +2160,11 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, preserve_write = prot_numa &&pmd_write (*pmd); ret =1 ; -#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION +#if defined(CONFIG_ARCH_ENABLE_THP_MIGRATION ) || defined(CONFIG_THP_SWAP )if (is_swap_pmd (*pmd)) {swp_entry_t entry =pmd_to_swp_entry (*pmd); -VM_BUG_ON (!is_pmd_migration_entry (*pmd)); +VM_BUG_ON (!thp_swap_supported () && !is_migration_entry (entry));if (is_write_migration_entry (entry)) {pmd_t newpmd;/*
mm/mempolicy.c +1 -1
@@ -436,7 +436,7 @@ static int queue_pages_pmd(pmd_t *pmd, spinlock_t *ptl, unsigned long addr,struct queue_pages *qp = walk->private;unsigned long flags; -if (unlikely (is_pmd_migration_entry (*pmd))) { +if (unlikely (is_swap_pmd (*pmd))) { ret =1 ; goto unlock; }
Signature · 1 line
2.16.1
PATCH 20/21 mm, THP, swap: create PMD swap mapping when unmap the THP
In reply to Huang, YingFrom: Huang Ying <[email protected]>
This is the final step of the THP swapin support. When reclaiming a anonymous THP, after allocating the huge swap cluster and add the THP into swap cache, the PMD page mapping will be changed to the mapping to the swap space. Previously, the PMD page mapping will be split before being changed. In this patch, the unmap code is enhanced not to split the PMD mapping, but create a PMD swap mapping to replace it instead. So later when clear the SWAP_HAS_CACHE flag in the last step of swapout, the huge swap cluster will be kept instead of being split, and when swapin, the huge swap cluster will be read as a whole into a THP. That is, the THP will not be split during swapout/swapin. This can eliminate the overhead of splitting/collapsing, and reduce the page fault count, etc. But more important, the utilization of THP is improved greatly, that is, much more THP will be kept when swapping is used, so that we can take full advantage of THP including its high performance for swapout/swapin.
--- include/linux/huge_mm.h | 11 +++++++++++ mm/huge_memory.c | 30 ++++++++++++++++++++++++++++++ mm/rmap.c | 43 +++++++++++++++++++++++++++++++++++++++++-- mm/vmscan.c | 6 +----- 4 files changed, 83 insertions(+), 7 deletions(-)
include/linux/huge_mm.h +11 -0
@@ -404,6 +404,8 @@ static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma) }#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ +struct page_vma_mapped_walk ; +#ifdef CONFIG_THP_SWAP extern void __split_huge_swap_pmd(struct vm_area_struct *vma, unsigned long haddr,
@@ -411,6 +413,8 @@ extern void __split_huge_swap_pmd(struct vm_area_struct *vma,extern int split_huge_swap_pmd (struct vm_area_struct *vma,pmd_t *pmd,unsigned long address,pmd_t orig_pmd);extern int do_huge_pmd_swap_page (struct vm_fault *vmf,pmd_t orig_pmd); +extern bool set_pmd_swap_entry (struct page_vma_mapped_walk *pvmw, +struct page *page,unsigned long address,pmd_t pmdval);static inline bool transparent_hugepage_swapin_enabled (struct vm_area_struct *vma)
@@ -452,6 +456,13 @@ static inline int do_huge_pmd_swap_page(struct vm_fault *vmf, pmd_t orig_pmd)return 0 ; } +static inline bool set_pmd_swap_entry (struct page_vma_mapped_walk *pvmw, +struct page *page,unsigned long address, +pmd_t pmdval) +{ +return false; +} +static inline bool transparent_hugepage_swapin_enabled (struct vm_area_struct *vma) {
mm/huge_memory.c +30 -0
@@ -1876,6 +1876,36 @@ int do_huge_pmd_swap_page(struct vm_fault *vmf, pmd_t orig_pmd)count_vm_event (THP_SWPIN_FALLBACK ); goto fallback; } + +bool set_pmd_swap_entry (struct page_vma_mapped_walk *pvmw,struct page *page, +unsigned long address,pmd_t pmdval) +{ +struct vm_area_struct *vma = pvmw->vma; +struct mm_struct *mm = vma->vm_mm; +pmd_t swp_pmd; +swp_entry_t entry = { .val =page_private (page) }; + +if (swap_duplicate (&entry, true) <0 ) { +set_pmd_at (mm, address, pvmw->pmd, pmdval); +return false; + } +if (list_empty (&mm->mmlist)) { +spin_lock (&mmlist_lock); +if (list_empty (&mm->mmlist)) +list_add (&mm->mmlist, &init_mm.mmlist); +spin_unlock (&mmlist_lock); + } +add_mm_counter (mm,MM_ANONPAGES , -HPAGE_PMD_NR ); +add_mm_counter (mm,MM_SWAPENTS ,HPAGE_PMD_NR ); + swp_pmd =swp_entry_to_pmd (entry); +if (pmd_soft_dirty (pmdval)) + swp_pmd =pmd_swp_mksoft_dirty (swp_pmd); +set_pmd_at (mm, address, pvmw->pmd, swp_pmd); + +page_remove_rmap (page, true); +put_page (page); +return true; +}#endif static inline void zap_deposited_table (struct mm_struct *mm,pmd_t *pmd)
mm/rmap.c +41 -2
53 lines not on this page · raw message
mm/vmscan.c +1 -5
@@ -1148,11 +1148,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,* processes. Try to unmap it here. */ if (page_mapped (page)) { -enum ttu_flags flags = ttu_flags |TTU_BATCH_FLUSH ; - -if (unlikely (PageTransHuge (page))) - flags |=TTU_SPLIT_HUGE_PMD ; -if (!try_to_unmap (page, flags)) { +if (!try_to_unmap (page, ttu_flags |TTU_BATCH_FLUSH )) { nr_unmap_fail++; goto activate_locked; }
Signature · 1 line
2.16.1
PATCH 21/21 mm, THP: Avoid to split THP when reclaim MADV_FREE THP
In reply to Huang, YingFrom: Huang Ying <[email protected]>
Previously, to reclaim MADV_FREE THP, the THP will be split firstly, then reclaim each sub-pages. This wastes cycles to split THP and unmap and free each sub-pages, and split THP even if it has been written since MADV_FREE. We have to do this because MADV_FREE THP reclaiming shares same try_to_unmap() calling with swap, while swap needs to split the PMD page mapping at that time. Now swap can process PMD mapping, this makes it easy to avoid to split THP when MADV_FREE THP is reclaimed.
--- mm/huge_memory.c | 41 ++++++++++++++++++++++++++++++++--------- mm/vmscan.c | 3 ++- 2 files changed, 34 insertions(+), 10 deletions(-)
mm/huge_memory.c +32 -9
@@ -1671,6 +1671,15 @@ int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t pmd)return 0 ; } +static inline void zap_deposited_table (struct mm_struct *mm,pmd_t *pmd) +{ +pgtable_t pgtable; + + pgtable =pgtable_trans_huge_withdraw (mm, pmd); +pte_free (mm, pgtable); +mm_dec_nr_ptes (mm); +} +#ifdef CONFIG_THP_SWAP void __split_huge_swap_pmd(struct vm_area_struct *vma, unsigned long haddr,
@@ -1885,6 +1894,28 @@ bool set_pmd_swap_entry(struct page_vma_mapped_walk *pvmw, struct page *page,pmd_t swp_pmd;swp_entry_t entry = { .val =page_private (page) }; +if (unlikely (PageSwapBacked (page) !=PageSwapCache (page))) { +WARN_ON_ONCE (1 ); +return false; + } + +/* MADV_FREE page check */ +if (!PageSwapBacked (page)) { +if (!PageDirty (page)) { +zap_deposited_table (mm, pvmw->pmd); +add_mm_counter (mm,MM_ANONPAGES , -HPAGE_PMD_NR ); + goto out_remove_rmap; + } + +/* +* If the page was redirtied, it cannot be +* discarded. Remap the page to page table. +*/ +set_pmd_at (mm, address, pvmw->pmd, pmdval); +SetPageSwapBacked (page); +return false; + } +if (swap_duplicate (&entry, true) <0 ) {set_pmd_at (mm, address, pvmw->pmd, pmdval);return false;
@@ -1902,21 +1933,13 @@ bool set_pmd_swap_entry(struct page_vma_mapped_walk *pvmw, struct page *page, swp_pmd =pmd_swp_mksoft_dirty (swp_pmd);set_pmd_at (mm, address, pvmw->pmd, swp_pmd); +out_remove_rmap:page_remove_rmap (page, true);put_page (page); return true; }#endif -static inline void zap_deposited_table (struct mm_struct *mm,pmd_t *pmd) -{ -pgtable_t pgtable; - - pgtable =pgtable_trans_huge_withdraw (mm, pmd); -pte_free (mm, pgtable); -mm_dec_nr_ptes (mm); -} -/* * Return true if we do MADV_FREE successfully on entire pmd page. * Otherwise, return false.
mm/vmscan.c +2 -1
@@ -1137,7 +1137,8 @@ static unsigned long shrink_page_list(struct list_head *page_list,/* Adding to swap updated mapping */ mapping =page_mapping (page); } - }else if (unlikely (PageTransHuge (page))) { + }else if (unlikely (PageTransHuge (page)) && + (!thp_swap_supported () || !PageAnon (page))) {/* Split file THP */ if (split_huge_page_to_list (page, page_list)) goto keep_locked;
Signature · 1 line
2.16.1
Quoted 10 lines · Ying
From: Huang Ying <[email protected]>
Hi, Andrew, could you help me to check whether the overall design is reasonable?
Hi, Hugh, Shaohua, Minchan and Rik, could you help me to review the swap part of the patchset? Especially [02/21], [03/21], [04/21], [05/21], [06/21], [07/21], [08/21], [09/21], [10/21], [11/21], [12/21], [20/21].
Quoted 8 lines
Hi, Andrea and Kirill, could you help me to review the THP part of the patchset? Especially [01/21], [07/21], [09/21], [11/21], [13/21], [15/21], [16/21], [17/21], [18/21], [19/21], [20/21], [21/21].
Hi, Johannes and Michal, could you help me to review the cgroup part of the patchset? Especially [14/21].
And for all, Any comment is welcome!
Hi Ying Huang,
I've read through this series and find no issue.
It seems that thp swapout never happens if swap devices are backed by rotation storages. I guess that's because this feature depends on swap cluster searching algorithm which only supports non-rotational storages.
I think that this limitation is OK because non-rotational storage is better for swap device (most future users will use it). But I think it's better to document the limitation somewhere because swap cluster is in-kernel thing and we can't assume that end users know about it.
Thanks,
Naoya Horiguchi
Quoted 107 lines
This patchset is based on the 2018-05-18 head of mmotm/master.
This is the final step of THP (Transparent Huge Page) swap optimization. After the first and second step, the splitting huge page is delayed from almost the first step of swapout to after swapout has been finished. In this step, we avoid splitting THP for swapout and swapout/swapin the THP in one piece.
We tested the patchset with vm-scalability benchmark swap-w-seq test case, with 16 processes. The test case forks 16 processes. Each process allocates large anonymous memory range, and writes it from begin to end for 8 rounds. The first round will swapout, while the remaining rounds will swapin and swapout. The test is done on a Xeon E5 v3 system, the swap device used is a RAM simulated PMEM (persistent memory) device. The test result is as follow,
base optimized
---------------- --------------------------
%stddev %change %stddev
\ | \1417897 ± 2% +992.8% 15494673 vm-scalability.throughput 1020489 ± 4% +1091.2% 12156349 vmstat.swap.si 1255093 ± 3% +940.3% 13056114 vmstat.swap.so 1259769 ± 7% +1818.3% 24166779 meminfo.AnonHugePages 28021761 -10.7% 25018848 ± 2% meminfo.AnonPages 64080064 ± 4% -95.6% 2787565 ± 33% interrupts.CAL:Function_call_interrupts 13.91 ± 5% -13.8 0.10 ± 27% perf-profile.children.cycles-pp.native_queued_spin_lock_slowpathWhere, the score of benchmark (bytes written per second) improved 992.8%. The swapout/swapin throughput improved 1008% (from about 2.17GB/s to 24.04GB/s). The performance difference is huge. In base kernel, for the first round of writing, the THP is swapout and split, so in the remaining rounds, there is only normal page swapin and swapout. While in optimized kernel, the THP is kept after first swapout, so THP swapin and swapout is used in the remaining rounds. This shows the key benefit to swapout/swapin THP in one piece, the THP will be kept instead of being split. meminfo information verified this, in base kernel only 4.5% of anonymous page are THP during the test, while in optimized kernel, that is 96.6%. The TLB flushing IPI (represented as interrupts.CAL:Function_call_interrupts) reduced 95.6%, while cycles for spinlock reduced from 13.9% to 0.1%. These are performance benefit of THP swapout/swapin too.
Below is the description for all steps of THP swap optimization.
Recently, the performance of the storage devices improved so fast that we cannot saturate the disk bandwidth with single logical CPU when do page swapping even on a high-end server machine. Because the performance of the storage device improved faster than that of single logical CPU. And it seems that the trend will not change in the near future. On the other hand, the THP becomes more and more popular because of increased memory size. So it becomes necessary to optimize THP swap performance.
The advantages to swapout/swapin a THP in one piece include:
- Batch various swap operations for the THP. Many operations need to be done once per THP instead of per normal page, for example, allocating/freeing the swap space, writing/reading the swap space, flushing TLB, page fault, etc. This will improve the performance of the THP swap greatly.
- The THP swap space read/write will be large sequential IO (2M on
x86_64). It is particularly helpful for the swapin, which are usually 4k random IO. This will improve the performance of the THP swap too.- It will help the memory fragmentation, especially when the THP is heavily used by the applications. The THP order pages will be free up after THP swapout.
- It will improve the THP utilization on the system with the swap turned on. Because the speed for khugepaged to collapse the normal pages into the THP is quite slow. After the THP is split during the swapout, it will take quite long time for the normal pages to collapse back into the THP after being swapin. The high THP utilization helps the efficiency of the page based memory management too.
There are some concerns regarding THP swapin, mainly because possible enlarged read/write IO size (for swapout/swapin) may put more overhead on the storage device. To deal with that, the THP swapin is turned on only when necessary. A new sysfs interface:
/sys/kernel/mm/transparent_hugepage/swapin_enabledis added to configure it. It uses "always/never/madvise" logic, to be turned on globally, turned off globally, or turned on only for VMA withMADV_HUGEPAGE, etc.
GE, etc.Changelog
---------v3:
- Rebased on 5/18 HEAD of mmotm/master
- Fixed a build bug, Thanks 0-Day!
v2:
- Fixed several build bugs, Thanks 0-Day!
- Improved documentation as suggested by Randy Dunlap.
- Fixed several bugs in reading huge swap cluster
Quoted 15 lines · Naoya Horiguchi
Quoted 14 lines · Ying
From: Huang Ying <[email protected]>
Hi, Andrew, could you help me to check whether the overall design is reasonable?
Hi, Hugh, Shaohua, Minchan and Rik, could you help me to review the swap part of the patchset? Especially [02/21], [03/21], [04/21], [05/21], [06/21], [07/21], [08/21], [09/21], [10/21], [11/21], [12/21], [20/21].
Hi, Andrea and Kirill, could you help me to review the THP part of the patchset? Especially [01/21], [07/21], [09/21], [11/21], [13/21], [15/21], [16/21], [17/21], [18/21], [19/21], [20/21], [21/21].
Quoted 7 lines
Quoted 4 lines
Hi, Johannes and Michal, could you help me to review the cgroup part of the patchset? Especially [14/21].
And for all, Any comment is welcome!
Hi Ying Huang,
I've read through this series and find no issue.
Thanks a lot for your review!
Quoted 8 lines
It seems that thp swapout never happens if swap devices are backed by rotation storages. I guess that's because this feature depends on swap cluster searching algorithm which only supports non-rotational storages.
I think that this limitation is OK because non-rotational storage is better for swap device (most future users will use it). But I think it's better to document the limitation somewhere because swap cluster is in-kernel thing and we can't assume that end users know about it.
Yes. I will try to document it somewhere.
Best Regards,
Huang, Ying
Quoted 110 lines
Thanks,
Naoya HoriguchiQuoted 107 lines
This patchset is based on the 2018-05-18 head of mmotm/master.
This is the final step of THP (Transparent Huge Page) swap optimization. After the first and second step, the splitting huge page is delayed from almost the first step of swapout to after swapout has been finished. In this step, we avoid splitting THP for swapout and swapout/swapin the THP in one piece.
We tested the patchset with vm-scalability benchmark swap-w-seq test case, with 16 processes. The test case forks 16 processes. Each process allocates large anonymous memory range, and writes it from begin to end for 8 rounds. The first round will swapout, while the remaining rounds will swapin and swapout. The test is done on a Xeon E5 v3 system, the swap device used is a RAM simulated PMEM (persistent memory) device. The test result is as follow,
base optimized
---------------- --------------------------
%stddev %change %stddev
\ | \1417897 ± 2% +992.8% 15494673 vm-scalability.throughput 1020489 ± 4% +1091.2% 12156349 vmstat.swap.si 1255093 ± 3% +940.3% 13056114 vmstat.swap.so 1259769 ± 7% +1818.3% 24166779 meminfo.AnonHugePages 28021761 -10.7% 25018848 ± 2% meminfo.AnonPages 64080064 ± 4% -95.6% 2787565 ± 33% interrupts.CAL:Function_call_interrupts 13.91 ± 5% -13.8 0.10 ± 27% perf-profile.children.cycles-pp.native_queued_spin_lock_slowpathWhere, the score of benchmark (bytes written per second) improved 992.8%. The swapout/swapin throughput improved 1008% (from about 2.17GB/s to 24.04GB/s). The performance difference is huge. In base kernel, for the first round of writing, the THP is swapout and split, so in the remaining rounds, there is only normal page swapin and swapout. While in optimized kernel, the THP is kept after first swapout, so THP swapin and swapout is used in the remaining rounds. This shows the key benefit to swapout/swapin THP in one piece, the THP will be kept instead of being split. meminfo information verified this, in base kernel only 4.5% of anonymous page are THP during the test, while in optimized kernel, that is 96.6%. The TLB flushing IPI (represented as interrupts.CAL:Function_call_interrupts) reduced 95.6%, while cycles for spinlock reduced from 13.9% to 0.1%. These are performance benefit of THP swapout/swapin too.
Below is the description for all steps of THP swap optimization.
Recently, the performance of the storage devices improved so fast that we cannot saturate the disk bandwidth with single logical CPU when do page swapping even on a high-end server machine. Because the performance of the storage device improved faster than that of single logical CPU. And it seems that the trend will not change in the near future. On the other hand, the THP becomes more and more popular because of increased memory size. So it becomes necessary to optimize THP swap performance.
The advantages to swapout/swapin a THP in one piece include:
- Batch various swap operations for the THP. Many operations need to be done once per THP instead of per normal page, for example, allocating/freeing the swap space, writing/reading the swap space, flushing TLB, page fault, etc. This will improve the performance of the THP swap greatly.
- The THP swap space read/write will be large sequential IO (2M on
x86_64). It is particularly helpful for the swapin, which are usually 4k random IO. This will improve the performance of the THP swap too.- It will help the memory fragmentation, especially when the THP is heavily used by the applications. The THP order pages will be free up after THP swapout.
- It will improve the THP utilization on the system with the swap turned on. Because the speed for khugepaged to collapse the normal pages into the THP is quite slow. After the THP is split during the swapout, it will take quite long time for the normal pages to collapse back into the THP after being swapin. The high THP utilization helps the efficiency of the page based memory management too.
There are some concerns regarding THP swapin, mainly because possible enlarged read/write IO size (for swapout/swapin) may put more overhead on the storage device. To deal with that, the THP swapin is turned on only when necessary. A new sysfs interface:
/sys/kernel/mm/transparent_hugepage/swapin_enabledis added to configure it. It uses "always/never/madvise" logic, to be turned on globally, turned off globally, or turned on only for VMA withMADV_HUGEPAGE, etc.
GE, etc.Changelog
---------v3:
- Rebased on 5/18 HEAD of mmotm/master
- Fixed a build bug, Thanks 0-Day!
v2:
- Fixed several build bugs, Thanks 0-Day!
- Improved documentation as suggested by Randy Dunlap.
- Fixed several bugs in reading huge swap cluster
Quoted 3 lines · Ying
And for all, Any comment is welcome!
This patchset is based on the 2018-05-18 head of mmotm/master.
Trying to review this and it doesn't apply to mmotm-2018-05-18-16-44. git fails on patch 10:
Applying: mm, THP, swap: Support to count THP swapin and its fallback
error: Documentation/vm/transhuge.rst: does not exist in index Patch failed at 0010 mm, THP, swap: Support to count THP swapin and its fallback
Sure enough, this tag has Documentation/vm/transhuge.txt but not the .rst version. Was this the tag you meant? If so did you pull in some of Mike Rapoport's doc changes on top?
Quoted 12 lines
base optimized
---------------- --------------------------
%stddev %change %stddev
\ | \1417897 +- 2% +992.8% 15494673 vm-scalability.throughput 1020489 +- 4% +1091.2% 12156349 vmstat.swap.si 1255093 +- 3% +940.3% 13056114 vmstat.swap.so 1259769 +- 7% +1818.3% 24166779 meminfo.AnonHugePages 28021761 -10.7% 25018848 +- 2% meminfo.AnonPages 64080064 +- 4% -95.6% 2787565 +- 33% interrupts.CAL:Function_call_interrupts 13.91 +- 5% -13.8 0.10 +- 27% perf-profile.children.cycles-pp.native_queued_spin_lock_slowpath
...snip...
Quoted 4 lines
test, while in optimized kernel, that is 96.6%. The TLB flushing IPI (represented as interrupts.CAL:Function_call_interrupts) reduced 95.6%, while cycles for spinlock reduced from 13.9% to 0.1%. These are performance benefit of THP swapout/swapin too.
Which spinlocks are we spending less time on?
Quoted 8 lines · Daniel Jordan
Quoted 3 lines · Ying
And for all, Any comment is welcome!
This patchset is based on the 2018-05-18 head of mmotm/master.
Trying to review this and it doesn't apply to mmotm-2018-05-18-16-44. git fails on patch 10:
Quoted 7 lines
Applying: mm, THP, swap: Support to count THP swapin and its fallback
error:Documentation/vm/transhuge.rst: does not exist in index Patch failed at 0010 mm, THP, swap: Support to count THP swapin and its fallbackSure enough, this tag has
Documentation/vm/transhuge.txtbut not the .rst version. Was this the tag you meant? If so did you pull in some of Mike Rapoport's doc changes on top?
I use the mmotm tree at
git://git.cmpxchg.org/linux-mmotm.git
Maybe you are using the other one?
Quoted 12 lines
Quoted 4 lines
base optimized
---------------- --------------------------
%stddev %change %stddev
\ | \Quoted 8 lines
1417897 2% +992.8% 15494673 vm-scalability.throughput 1020489 4% +1091.2% 12156349 vmstat.swap.si 1255093 3% +940.3% 13056114 vmstat.swap.so 1259769 7% +1818.3% 24166779 meminfo.AnonHugePages 28021761 -10.7% 25018848 2% meminfo.AnonPages 64080064 4% -95.6% 2787565 33% interrupts.CAL:Function_call_interrupts 13.91 5% -13.8 0.10 27% perf-profile.children.cycles-pp.native_queued_spin_lock_slowpath
Quoted 7 lines
...snip...
Quoted 4 lines
test, while in optimized kernel, that is 96.6%. The TLB flushing IPI (represented as interrupts.CAL:Function_call_interrupts) reduced 95.6%, while cycles for spinlock reduced from 13.9% to 0.1%. These are performance benefit of THP swapout/swapin too.
Which spinlocks are we spending less time on?
"perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock_irq.mem_cgroup_commit_charge.do_swap_page.__handle_mm_fault": 4.39, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock.free_pcppages_bulk.drain_pages_zone.drain_pages": 1.53, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock.get_page_from_freelist.__alloc_pages_slowpath.__alloc_pages_nodemask": 1.34, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock.swapcache_free_entries.free_swap_slot.do_swap_page": 1.02, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock_irq.shrink_inactive_list.shrink_node_memcg.shrink_node": 0.61, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock_irq.shrink_active_list.shrink_node_memcg.shrink_node": 0.54,
Best Regards,
Huang, Ying
Quoted 18 lines · Ying
Quoted 8 lines · Daniel Jordan
Quoted 3 lines · Ying
And for all, Any comment is welcome!
This patchset is based on the 2018-05-18 head of mmotm/master.
Trying to review this and it doesn't apply to mmotm-2018-05-18-16-44. git fails on patch 10:
Quoted 7 lines
Applying: mm, THP, swap: Support to count THP swapin and its fallback
error:Documentation/vm/transhuge.rst: does not exist in index Patch failed at 0010 mm, THP, swap: Support to count THP swapin and its fallbackSure enough, this tag has
Documentation/vm/transhuge.txtbut not the .rst version. Was this the tag you meant? If so did you pull in some of Mike Rapoport's doc changes on top?
Quoted 5 lines
I use the mmotm tree at
git://git.cmpxchg.org/linux-mmotm.gitMaybe you are using the other one?
Yes I was, and I didn't know about this other tree, thanks! Working my way through your changes now.
Quoted 19 lines
Quoted 19 lines
Quoted 13 lines
base optimized
---------------- --------------------------
%stddev %change %stddev
\ | \1417897 2% +992.8% 15494673 vm-scalability.throughput 1020489 4% +1091.2% 12156349 vmstat.swap.si 1255093 3% +940.3% 13056114 vmstat.swap.so 1259769 7% +1818.3% 24166779 meminfo.AnonHugePages 28021761 -10.7% 25018848 2% meminfo.AnonPages 64080064 4% -95.6% 2787565 33% interrupts.CAL:Function_call_interrupts 13.91 5% -13.8 0.10 27% perf-profile.children.cycles-pp.native_queued_spin_lock_slowpath...snip...
Quoted 4 lines
test, while in optimized kernel, that is 96.6%. The TLB flushing IPI (represented as interrupts.CAL:Function_call_interrupts) reduced 95.6%, while cycles for spinlock reduced from 13.9% to 0.1%. These are performance benefit of THP swapout/swapin too.
Quoted 8 lines
Quoted 1 line
Which spinlocks are we spending less time on?
"perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock_irq.mem_cgroup_commit_charge.do_swap_page.__handle_mm_fault": 4.39, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock.free_pcppages_bulk.drain_pages_zone.drain_pages": 1.53, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock.get_page_from_freelist.__alloc_pages_slowpath.__alloc_pages_nodemask": 1.34, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock.swapcache_free_entries.free_swap_slot.do_swap_page": 1.02, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock_irq.shrink_inactive_list.shrink_node_memcg.shrink_node": 0.61, "perf-profile.calltrace.cycles-pp.native_queued_spin_lock_slowpath._raw_spin_lock_irq.shrink_active_list.shrink_node_memcg.shrink_node": 0.54,
Nice, seems like lru_lock followed by zone->lock are the main improvements.