Skip to contentSkip to conversation

relax anon mTHP PTE Mapping restrictions

RFC In review Lance Yang 3 participants 7 messages Jan 20, 2025 – Jan 21, 2025

Subsystems (2)
lore
Share & tools
lore

Lance Yang

author
#0 lore raw

cover relax anon mTHP PTE Mapping restrictions

Hey all,

Previously, mTHP could only be mapped to PTEs where all entries were none. With this change, PTEs within the range mapping the demand-zero page can now be treated as pte_none and remapped to a new mTHP, providing more opportunities to take advantage of mTHP.

Lance Yang (2):
mm/mthp: add pte_range_none_or_zeropfn() helper mm/mthp: relax anon mTHP PTE Mapping restrictions

 mm/memory.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 49 insertions(+), 5 deletions(-)
Signature · 1 line
2.45.2
author
#1 lore raw

RFC 1/2 mm/mthp: add pte_range_none_or_zeropfn() helper

In preparation for relaxing the mTHP PTE mapping restriction on the demand zero page. We intend to provide more opportunities to take advantage of mTHP.

---
 mm/memory.c | 43 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 40 insertions(+), 3 deletions(-)
mm/memory.c +40 -3
index 2a20e3810534..4e148309b3e0 100644
@@ -4724,18 +4724,55 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 	return ret;
 }
 
-static bool pte_range_none(pte_t *pte, int nr_pages)
+/* Flags for __pte_range_check(). */
+typedef int __bitwise prc_t;
+
+/* Check if PTEs are not present. */
+#define PRC_CHECK_NONE ((__force prc_t)BIT(0))
+
+/* Check if PTEs are mapped to the zero page. */
+#define PRC_CHECK_ZEROPFN ((__force prc_t)BIT(1))
+
+static bool __pte_range_check(pte_t *pte, int nr_pages, prc_t flags,
+			      bool *any_zeropfn)
 {
 	int i;
+	pte_t ptent;
+
+	if (any_zeropfn)
+		*any_zeropfn = false;
 
 	for (i = 0; i < nr_pages; i++) {
-		if (!pte_none(ptep_get_lockless(pte + i)))
-			return false;
+		ptent = ptep_get_lockless(pte + i);
+
+		if ((flags & PRC_CHECK_NONE) && pte_none(ptent))
+			continue;
+
+		if ((flags & PRC_CHECK_ZEROPFN) &&
+		    is_zero_pfn(pte_pfn(ptent))) {
+			if (any_zeropfn)
+				*any_zeropfn = true;
+			continue;
+		}
+
+		return false;
 	}
 
 	return true;
 }
 
+static inline bool pte_range_none(pte_t *pte, int nr_pages)
+{
+	return __pte_range_check(pte, nr_pages, PRC_CHECK_NONE, NULL);
+}
+
+static inline bool pte_range_none_or_zeropfn(pte_t *pte, int nr_pages,
+					     bool *any_zeropfn)
+{
+	return __pte_range_check(
+		pte, nr_pages, PRC_CHECK_NONE | PRC_CHECK_ZEROPFN, any_zeropfn);
+}
+
 static struct folio *alloc_anon_folio(struct vm_fault *vmf)
 {
 	struct vm_area_struct *vma = vmf->vma;
Signature · 1 line
2.45.2
author
#2 lore raw

RFC 2/2 mm/mthp: relax anon mTHP PTE Mapping restrictions

In reply to Lance Yang

Previously, mTHP could only be mapped to PTEs where all entries were none. With this change, PTEs within the range mapping the demand-zero page can now be treated as pte_none and remapped to a new mTHP, providing more opportunities to take advantage of mTHP.

---
 mm/memory.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)
mm/memory.c +9 -2
index 4e148309b3e0..99ec75c6f0fe 100644
@@ -4815,7 +4815,8 @@ static struct folio *alloc_anon_folio(struct vm_fault *vmf)
 	order = highest_order(orders);
 	while (orders) {
 		addr = ALIGN_DOWN(vmf->address, PAGE_SIZE << order);
-		if (pte_range_none(pte + pte_index(addr), 1 << order))
+		if (pte_range_none_or_zeropfn(pte + pte_index(addr), 1 << order,
+					      NULL))
 			break;
 		order = next_order(&orders, order);
 	}
@@ -4867,6 +4868,7 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
 {
 	struct vm_area_struct *vma = vmf->vma;
 	unsigned long addr = vmf->address;
+	bool any_zeropfn = false;
 	struct folio *folio;
 	vm_fault_t ret = 0;
 	int nr_pages = 1;
@@ -4939,7 +4941,8 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
 	if (nr_pages == 1 && vmf_pte_changed(vmf)) {
 		update_mmu_tlb(vma, addr, vmf->pte);
 		goto release;
-	} else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
+	} else if (nr_pages > 1 && !pte_range_none_or_zeropfn(
+					   vmf->pte, nr_pages, &any_zeropfn)) {
 		update_mmu_tlb_range(vma, addr, vmf->pte, nr_pages);
 		goto release;
 	}
@@ -4965,6 +4968,10 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
 		entry = pte_mkuffd_wp(entry);
 	set_ptes(vma->vm_mm, addr, vmf->pte, entry, nr_pages);
 
+	/* At least one PTE was mapped to the zero page */
+	if (nr_pages > 1 && any_zeropfn)
+		flush_tlb_range(vma, addr, addr + (nr_pages * PAGE_SIZE));
+
 	/* No need to invalidate - it was non-present before */
 	update_mmu_cache_range(vmf, vma, addr, vmf->pte, nr_pages);
 unlock:
Signature · 1 line
2.45.2
#3 lore raw

Re: [RFC 2/2] mm/mthp: relax anon mTHP PTE Mapping restrictions

Quoted 45 lines · Lance Yang

Previously, mTHP could only be mapped to PTEs where all entries were none. With this change, PTEs within the range mapping the demand-zero page can now be treated as pte_none and remapped to a new mTHP, providing more opportunities to take advantage of mTHP.

---
 mm/memory.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)
mm/memory.c +5 -2
index 4e148309b3e0..99ec75c6f0fe 100644
@@ -4815,7 +4815,8 @@ static struct folio *alloc_anon_folio(struct vm_fault *vmf)
        order = highest_order(orders);
        while (orders) {
                addr = ALIGN_DOWN(vmf->address, PAGE_SIZE << order);
-               if (pte_range_none(pte + pte_index(addr), 1 << order))
+               if (pte_range_none_or_zeropfn(pte + pte_index(addr), 1 << order,
+                                             NULL))
                        break;
                order = next_order(&orders, order);
        }
@@ -4867,6 +4868,7 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
        unsigned long addr = vmf->address;
+       bool any_zeropfn = false;
        struct folio *folio;
        vm_fault_t ret = 0;
        int nr_pages = 1;
@@ -4939,7 +4941,8 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
        if (nr_pages == 1 && vmf_pte_changed(vmf)) {
                update_mmu_tlb(vma, addr, vmf->pte);
                goto release;
-       } else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
+       } else if (nr_pages > 1 && !pte_range_none_or_zeropfn(
+                                          vmf->pte, nr_pages, &any_zeropfn)) {
                update_mmu_tlb_range(vma, addr, vmf->pte, nr_pages);
                goto release;
        }

mm/memory.c static vm_fault_t do_anonymous_page(struct vm_fault *vmf) · line 4973

Quoted 6 lines
mm/memory.c +3 -0
@@ -4965,6 +4968,10 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
                entry = pte_mkuffd_wp(entry);
        set_ptes(vma->vm_mm, addr, vmf->pte, entry, nr_pages);
 
+       /* At least one PTE was mapped to the zero page */
+       if (nr_pages > 1 && any_zeropfn)
+               flush_tlb_range(vma, addr, addr + (nr_pages * PAGE_SIZE));

Do we also need mmu_notifier?

        mmu_notifier_range_init(...)
        mmu_notifier_invalidate_range_start(&range);

By the way, this is getting much more complex, but are we seeing any real benefits? I’ve tested this before, and it seems that zeropfn-mapped anonymous folios are quite rare.

Quoted 7 lines
mm/memory.c +1 -1
+
        /* No need to invalidate - it was non-present before */
        update_mmu_cache_range(vmf, vma, addr, vmf->pte, nr_pages);
 unlock:
--

2.45.2

Thanks
Barry

author
#4 lore raw

Re: [RFC 2/2] mm/mthp: relax anon mTHP PTE Mapping restrictions

Quoted 50 lines · Barry Song
Quoted 48 lines · Lance Yang

Previously, mTHP could only be mapped to PTEs where all entries were none. With this change, PTEs within the range mapping the demand-zero page can now be treated as pte_none and remapped to a new mTHP, providing more opportunities to take advantage of mTHP.

---
 mm/memory.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)
mm/memory.c +5 -2
index 4e148309b3e0..99ec75c6f0fe 100644
@@ -4815,7 +4815,8 @@ static struct folio *alloc_anon_folio(struct vm_fault *vmf)
        order = highest_order(orders);
        while (orders) {
                addr = ALIGN_DOWN(vmf->address, PAGE_SIZE << order);
-               if (pte_range_none(pte + pte_index(addr), 1 << order))
+               if (pte_range_none_or_zeropfn(pte + pte_index(addr), 1 << order,
+                                             NULL))
                        break;
                order = next_order(&orders, order);
        }
@@ -4867,6 +4868,7 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
 {
        struct vm_area_struct *vma = vmf->vma;
        unsigned long addr = vmf->address;
+       bool any_zeropfn = false;
        struct folio *folio;
        vm_fault_t ret = 0;
        int nr_pages = 1;
@@ -4939,7 +4941,8 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
        if (nr_pages == 1 && vmf_pte_changed(vmf)) {
                update_mmu_tlb(vma, addr, vmf->pte);
                goto release;
-       } else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
+       } else if (nr_pages > 1 && !pte_range_none_or_zeropfn(
+                                          vmf->pte, nr_pages, &any_zeropfn)) {
                update_mmu_tlb_range(vma, addr, vmf->pte, nr_pages);
                goto release;
        }
@@ -4965,6 +4968,10 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
                entry = pte_mkuffd_wp(entry);
        set_ptes(vma->vm_mm, addr, vmf->pte, entry, nr_pages);
 
Quoted 4 lines

mm/memory.c static vm_fault_t do_anonymous_page(struct vm_fault *vmf) · line 4973

Quoted 3 lines
mm/memory.c +3 -0
+       /* At least one PTE was mapped to the zero page */
+       if (nr_pages > 1 && any_zeropfn)
+               flush_tlb_range(vma, addr, addr + (nr_pages * PAGE_SIZE));

Thanks for taking time to review!

Quoted 8 lines

Do we also need mmu_notifier?

        mmu_notifier_range_init(...)
        mmu_notifier_invalidate_range_start(&range);

By the way, this is getting much more complex, but are we seeing any real benefits? I’ve tested this before, and it seems that zeropfn-mapped anonymous folios are quite rare.

Hmm... Agreed that it's getting more complex. I don't have any data showing real benefits yet, so let's put this patch aside for now until I do.

Thanks,
Lance

Quoted 11 lines
Quoted 8 lines
mm/memory.c +1 -1
+
        /* No need to invalidate - it was non-present before */
        update_mmu_cache_range(vmf, vma, addr, vmf->pte, nr_pages);
 unlock:
--

2.45.2

Thanks
Barry

#5 lore raw

Re: [RFC 2/2] mm/mthp: relax anon mTHP PTE Mapping restrictions

Quoted 63 lines · Lance Yang
Quoted 50 lines · Barry Song
Quoted 48 lines · Lance Yang

Previously, mTHP could only be mapped to PTEs where all entries were none. With this change, PTEs within the range mapping the demand-zero page can now be treated as pte_none and remapped to a new mTHP, providing more opportunities to take advantage of mTHP.

---
  mm/memory.c | 11 +++++++++--
  1 file changed, 9 insertions(+), 2 deletions(-)
mm/memory.c +5 -2
index 4e148309b3e0..99ec75c6f0fe 100644
@@ -4815,7 +4815,8 @@ static struct folio *alloc_anon_folio(struct vm_fault *vmf)
         order = highest_order(orders);
         while (orders) {
                 addr = ALIGN_DOWN(vmf->address, PAGE_SIZE << order);
-               if (pte_range_none(pte + pte_index(addr), 1 << order))
+               if (pte_range_none_or_zeropfn(pte + pte_index(addr), 1 << order,
+                                             NULL))
                         break;
                 order = next_order(&orders, order);
         }
@@ -4867,6 +4868,7 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
  {
         struct vm_area_struct *vma = vmf->vma;
         unsigned long addr = vmf->address;
+       bool any_zeropfn = false;
         struct folio *folio;
         vm_fault_t ret = 0;
         int nr_pages = 1;
@@ -4939,7 +4941,8 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
         if (nr_pages == 1 && vmf_pte_changed(vmf)) {
                 update_mmu_tlb(vma, addr, vmf->pte);
                 goto release;
-       } else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
+       } else if (nr_pages > 1 && !pte_range_none_or_zeropfn(
+                                          vmf->pte, nr_pages, &any_zeropfn)) {
                 update_mmu_tlb_range(vma, addr, vmf->pte, nr_pages);
                 goto release;
         }
@@ -4965,6 +4968,10 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
                 entry = pte_mkuffd_wp(entry);
         set_ptes(vma->vm_mm, addr, vmf->pte, entry, nr_pages);
 
Quoted 4 lines

mm/memory.c static vm_fault_t do_anonymous_page(struct vm_fault *vmf) · line 4973

Quoted 3 lines
mm/memory.c +3 -0
+       /* At least one PTE was mapped to the zero page */
+       if (nr_pages > 1 && any_zeropfn)
+               flush_tlb_range(vma, addr, addr + (nr_pages * PAGE_SIZE));

Thanks for taking time to review!

Quoted 5 lines

Do we also need mmu_notifier?

         mmu_notifier_range_init(...)
         mmu_notifier_invalidate_range_start(&range);
Quoted 6 lines
Quoted 3 lines

By the way, this is getting much more complex, but are we seeing any real benefits? I’ve tested this before, and it seems that zeropfn-mapped anonymous folios are quite rare.

Hmm... Agreed that it's getting more complex. I don't have any data showing real benefits yet, so let's put this patch aside for now until I do.

The motivation for the huge zeropage case was that we would install the huge zeropage on read fault, to then PTE-map it on write fault and only COW a single PTE. It would require khugepaged to collapse in order to get a THP again.

So read-then-immediately-write would not give us a PMD-mapped THP with the huge shared zeropage enabled, but would give us a PMD-mapped THP with the huge shared zeropage disabled, which is rather inconsistent.

In case of mTHP, the behavior is at least always the same, and the performance gain is likely not as huge as in the PMD case. Maybe we can just wait until khugepaged will fix it up, where a lot of that complexity will reside either way.

So I agree that it might be useful, but also that there must be a good reason to have that complexity here.

It might also be a valid question if we should even always use the shared zeropage on read faults with mTHP enabled, because maybe it could be more efficient to avoid the TLB flush when ripping out the shared zeropage etc and just give it an mTHP, if our shrinker works as expected

Using the huge zeropage is rather "obviously good" because it also reduces TLB pressure + page table walk and can be zapped fairly easily and efficiently to install a fresh PMD-mapped THP.

Signature · 3 lines
Cheers,

David / dhildenb
author
#6 lore raw

Re: [RFC 2/2] mm/mthp: relax anon mTHP PTE Mapping restrictions

Quoted 65 lines · David Hildenbrand
Quoted 63 lines · Lance Yang
Quoted 50 lines · Barry Song
Quoted 48 lines · Lance Yang

Previously, mTHP could only be mapped to PTEs where all entries were none. With this change, PTEs within the range mapping the demand-zero page can now be treated as pte_none and remapped to a new mTHP, providing more opportunities to take advantage of mTHP.

---
  mm/memory.c | 11 +++++++++--
  1 file changed, 9 insertions(+), 2 deletions(-)
mm/memory.c +5 -2
index 4e148309b3e0..99ec75c6f0fe 100644
@@ -4815,7 +4815,8 @@ static struct folio *alloc_anon_folio(struct vm_fault *vmf)
         order = highest_order(orders);
         while (orders) {
                 addr = ALIGN_DOWN(vmf->address, PAGE_SIZE << order);
-               if (pte_range_none(pte + pte_index(addr), 1 << order))
+               if (pte_range_none_or_zeropfn(pte + pte_index(addr), 1 << order,
+                                             NULL))
                         break;
                 order = next_order(&orders, order);
         }
@@ -4867,6 +4868,7 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
  {
         struct vm_area_struct *vma = vmf->vma;
         unsigned long addr = vmf->address;
+       bool any_zeropfn = false;
         struct folio *folio;
         vm_fault_t ret = 0;
         int nr_pages = 1;
@@ -4939,7 +4941,8 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
         if (nr_pages == 1 && vmf_pte_changed(vmf)) {
                 update_mmu_tlb(vma, addr, vmf->pte);
                 goto release;
-       } else if (nr_pages > 1 && !pte_range_none(vmf->pte, nr_pages)) {
+       } else if (nr_pages > 1 && !pte_range_none_or_zeropfn(
+                                          vmf->pte, nr_pages, &any_zeropfn)) {
                 update_mmu_tlb_range(vma, addr, vmf->pte, nr_pages);
                 goto release;
         }
@@ -4965,6 +4968,10 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
                 entry = pte_mkuffd_wp(entry);
         set_ptes(vma->vm_mm, addr, vmf->pte, entry, nr_pages);
 
Quoted 4 lines

mm/memory.c static vm_fault_t do_anonymous_page(struct vm_fault *vmf) · line 4973

Quoted 3 lines
mm/memory.c +3 -0
+       /* At least one PTE was mapped to the zero page */
+       if (nr_pages > 1 && any_zeropfn)
+               flush_tlb_range(vma, addr, addr + (nr_pages * PAGE_SIZE));

Thanks for taking time to review!

Quoted 5 lines

Do we also need mmu_notifier?

         mmu_notifier_range_init(...)
         mmu_notifier_invalidate_range_start(&range);
Quoted 7 lines
Quoted 6 lines
Quoted 3 lines

By the way, this is getting much more complex, but are we seeing any real benefits? I’ve tested this before, and it seems that zeropfn-mapped anonymous folios are quite rare.

Hmm... Agreed that it's getting more complex. I don't have any data showing real benefits yet, so let's put this patch aside for now until I do.

Thanks so much for the lesson! It's really helpful to me ;)

Quoted 4 lines

The motivation for the huge zeropage case was that we would install the huge zeropage on read fault, to then PTE-map it on write fault and only COW a single PTE. It would require khugepaged to collapse in order to get a THP again.

One thing I’d like to do is adjust the patch[1] and resend that out.

Case1: After a read-then-immediately-write operation, we end up with a PTE-mapped huge zeropage and one PTE-mapped page.

Case 2: Most PTEs within the PMD are set to none.

In either case, we can pre-zero the new THP before khugepaged collapses the PMD, which will reduce the process-visible downtime ;)

Do you see this as a useful improvement?

[1] https://lore.kernel.org/linux-mm/[email protected]/

Quoted 9 lines

So read-then-immediately-write would not give us a PMD-mapped THP with the huge shared zeropage enabled, but would give us a PMD-mapped THP with the huge shared zeropage disabled, which is rather inconsistent.

In case of mTHP, the behavior is at least always the same, and the performance gain is likely not as huge as in the PMD case. Maybe we can just wait until khugepaged will fix it up, where a lot of that complexity will reside either way.

Yeah, It’s better to let khugepaged handle that and keep the complexity on its side.

Quoted 9 lines

So I agree that it might be useful, but also that there must be a good reason to have that complexity here.

It might also be a valid question if we should even always use the shared zeropage on read faults with mTHP enabled, because maybe it could be more efficient to avoid the TLB flush when ripping out the shared zeropage etc and just give it an mTHP, if our shrinker works as expected

It sounds good to me ;p

Perhaps we could add a switch to just give it an mTHP on read faults with mTHP enabled, instead of always using the shared zeropage. Would this switch be per-process or per-cgroup? If it makes sense, I’d like to get involved.

Quoted 4 lines

Using the huge zeropage is rather "obviously good" because it also reduces TLB pressure + page table walk and can be zapped fairly easily and efficiently to install a fresh PMD-mapped THP.

Yep, as for the huge zeropage, it’s indeed better than the shared zeropage for reducing TLB pressure and page table walks. TBH, the shared zeropage is less effective for mTHP than the huge zeropage is for THP.

Thanks,
Lance

Quoted 6 lines

--
Cheers,

David / dhildenb