Baolin Wang <baolin.wang@xxxxxxxxxxxxxxxxx> writes:
> Now the anonymous page allocation already supports multi-size THP (mTHP),
> but the numa balancing still prohibits mTHP migration even though it is an
> exclusive mapping, which is unreasonable.
>
> Allow scanning mTHP:
> Commit 859d4adc3415 ("mm: numa: do not trap faults on shared data section
> pages") skips shared CoW pages' NUMA page migration to avoid shared data
> segment migration. In addition, commit 80d47f5de5e3 ("mm: don't try to
> NUMA-migrate COW pages that have other uses") change to use page_count()
> to avoid GUP pages migration, that will also skip the mTHP numa scaning.
> Theoretically, we can use folio_maybe_dma_pinned() to detect the GUP
> issue, although there is still a GUP race, the issue seems to have been
> resolved by commit 80d47f5de5e3. Meanwhile, use the folio_likely_mapped_shared()
> to skip shared CoW pages though this is not a precise sharers count. To
> check if the folio is shared, ideally we want to make sure every page is
> mapped to the same process, but doing that seems expensive and using
> the estimated mapcount seems can work when running autonuma benchmark.
>
> Allow migrating mTHP:
> As mentioned in the previous thread[1], large folios (including THP) are
> more susceptible to false sharing issues among threads than 4K base page,
> leading to pages ping-pong back and forth during numa balancing, which is
> currently not easy to resolve. Therefore, as a start to support mTHP numa
> balancing, we can follow the PMD mapped THP's strategy, that means we can
> reuse the 2-stage filter in should_numa_migrate_memory() to check if the
> mTHP is being heavily contended among threads (through checking the CPU id
> and pid of the last access) to avoid false sharing at some degree. Thus,
> we can restore all PTE maps upon the first hint page fault of a large folio
> to follow the PMD mapped THP's strategy. In the future, we can continue to
> optimize the NUMA balancing algorithm to avoid the false sharing issue with
> large folios as much as possible.
>
> Performance data:
> Machine environment: 2 nodes, 128 cores Intel(R) Xeon(R) Platinum
> Base: 2024-03-25 mm-unstable branch
> Enable mTHP to run autonuma-benchmark
>
> mTHP:16K
> Base Patched
> numa01 numa01
> 224.70 143.48
> numa01_THREAD_ALLOC numa01_THREAD_ALLOC
> 118.05 47.43
> numa02 numa02
> 13.45 9.29
> numa02_SMT numa02_SMT
> 14.80 7.50
>
> mTHP:64K
> Base Patched
> numa01 numa01
> 216.15 114.40
> numa01_THREAD_ALLOC numa01_THREAD_ALLOC
> 115.35 47.41
> numa02 numa02
> 13.24 9.25
> numa02_SMT numa02_SMT
> 14.67 7.34
>
> mTHP:128K
> Base Patched
> numa01 numa01
> 205.13 144.45
> numa01_THREAD_ALLOC numa01_THREAD_ALLOC
> 112.93 41.88
> numa02 numa02
> 13.16 9.18
> numa02_SMT numa02_SMT
> 14.81 7.49
>
> [1] https://lore.kernel.org/all/20231117100745.fnpijbk4xgmals3k@xxxxxxxxxxxxxxxxxxx/
> Signed-off-by: Baolin Wang <baolin.wang@xxxxxxxxxxxxxxxxx>
> ---
> mm/memory.c | 57 +++++++++++++++++++++++++++++++++++++++++++--------
> mm/mprotect.c | 3 ++-
> 2 files changed, 51 insertions(+), 9 deletions(-)
>
> diff --git a/mm/memory.c b/mm/memory.c
> index c30fb4b95e15..2aca19e4fbd8 100644
> --- a/mm/memory.c
> +++ b/mm/memory.c
> @@ -5068,16 +5068,56 @@ static void numa_rebuild_single_mapping(struct vm_fault *vmf, struct vm_area_str
> update_mmu_cache_range(vmf, vma, vmf->address, vmf->pte, 1);
> }
>
> +static void numa_rebuild_large_mapping(struct vm_fault *vmf, struct vm_area_struct *vma,
> + struct folio *folio, pte_t fault_pte, bool ignore_writable)
> +{
> + int nr = pte_pfn(fault_pte) - folio_pfn(folio);
> + unsigned long start = max(vmf->address - nr * PAGE_SIZE, vma->vm_start);
> + unsigned long end = min(vmf->address + (folio_nr_pages(folio) - nr) * PAGE_SIZE, vma->vm_end);
> + pte_t *start_ptep = vmf->pte - (vmf->address - start) / PAGE_SIZE;
> + bool pte_write_upgrade = vma_wants_manual_pte_write_upgrade(vma);
We call vma_wants_manual_pte_write_upgrade() in do_numa_page() already.
It seems that we can make "ignore_writable = true" if
"vma_wants_manual_pte_write_upgrade() == false" in do_numa_page() to
remove one call.
Otherwise, the patchset LGTM, feel free to add
Reviewed-by: "Huang, Ying" <ying.huang@xxxxxxxxx>
in the future versions.
--
Best Regards,
Huang, Ying
> + unsigned long addr;
> +
> + /* Restore all PTEs' mapping of the large folio */
> + for (addr = start; addr != end; start_ptep++, addr += PAGE_SIZE) {
> + pte_t pte, old_pte;
> + pte_t ptent = ptep_get(start_ptep);
> + bool writable = false;
> +
> + if (!pte_present(ptent) || !pte_protnone(ptent))
> + continue;
> +
> + if (pfn_folio(pte_pfn(ptent)) != folio)
> + continue;
> +
> + if (!ignore_writable) {
> + ptent = pte_modify(ptent, vma->vm_page_prot);
> + writable = pte_write(ptent);
> + if (!writable && pte_write_upgrade &&
> + can_change_pte_writable(vma, addr, ptent))
> + writable = true;
> + }
> +
> + old_pte = ptep_modify_prot_start(vma, addr, start_ptep);
> + pte = pte_modify(old_pte, vma->vm_page_prot);
> + pte = pte_mkyoung(pte);
> + if (writable)
> + pte = pte_mkwrite(pte, vma);
> + ptep_modify_prot_commit(vma, addr, start_ptep, old_pte, pte);
> + update_mmu_cache_range(vmf, vma, addr, start_ptep, 1);
> + }
> +}
> +
> static vm_fault_t do_numa_page(struct vm_fault *vmf)
> {
> struct vm_area_struct *vma = vmf->vma;
> struct folio *folio = NULL;
> int nid = NUMA_NO_NODE;
> - bool writable = false;
> + bool writable = false, ignore_writable = false;
> int last_cpupid;
> int target_nid;
> pte_t pte, old_pte;
> - int flags = 0;
> + int flags = 0, nr_pages;
>
> /*
> * The pte cannot be used safely until we verify, while holding the page
> @@ -5107,10 +5147,6 @@ static vm_fault_t do_numa_page(struct vm_fault *vmf)
> if (!folio || folio_is_zone_device(folio))
> goto out_map;
>
> - /* TODO: handle PTE-mapped THP */
> - if (folio_test_large(folio))
> - goto out_map;
> -
> /*
> * Avoid grouping on RO pages in general. RO pages shouldn't hurt as
> * much anyway since they can be in shared cache state. This misses
> @@ -5130,6 +5166,7 @@ static vm_fault_t do_numa_page(struct vm_fault *vmf)
> flags |= TNF_SHARED;
>
> nid = folio_nid(folio);
> + nr_pages = folio_nr_pages(folio);
> /*
> * For memory tiering mode, cpupid of slow memory page is used
> * to record page access time. So use default value.
> @@ -5146,6 +5183,7 @@ static vm_fault_t do_numa_page(struct vm_fault *vmf)
> }
> pte_unmap_unlock(vmf->pte, vmf->ptl);
> writable = false;
> + ignore_writable = true;
>
> /* Migrate to the requested node */
> if (migrate_misplaced_folio(folio, vma, target_nid)) {
> @@ -5166,14 +5204,17 @@ static vm_fault_t do_numa_page(struct vm_fault *vmf)
>
> out:
> if (nid != NUMA_NO_NODE)
> - task_numa_fault(last_cpupid, nid, 1, flags);
> + task_numa_fault(last_cpupid, nid, nr_pages, flags);
> return 0;
> out_map:
> /*
> * Make it present again, depending on how arch implements
> * non-accessible ptes, some can allow access by kernel mode.
> */
> - numa_rebuild_single_mapping(vmf, vma, writable);
> + if (folio && folio_test_large(folio))
> + numa_rebuild_large_mapping(vmf, vma, folio, pte, ignore_writable);
> + else
> + numa_rebuild_single_mapping(vmf, vma, writable);
> pte_unmap_unlock(vmf->pte, vmf->ptl);
> goto out;
> }
> diff --git a/mm/mprotect.c b/mm/mprotect.c
> index f8a4544b4601..94878c39ee32 100644
> --- a/mm/mprotect.c
> +++ b/mm/mprotect.c
> @@ -129,7 +129,8 @@ static long change_pte_range(struct mmu_gather *tlb,
>
> /* Also skip shared copy-on-write pages */
> if (is_cow_mapping(vma->vm_flags) &&
> - folio_ref_count(folio) != 1)
> + (folio_maybe_dma_pinned(folio) ||
> + folio_likely_mapped_shared(folio)))
> continue;
>
> /*
