Reduce TLB flushes by 94% by improving folio migration
Subsystems (10)
Byungchul Park
reviewerv7 cover Reduce TLB flushes by 94% by improving folio migration
Hi everyone,
While I'm working with CXL memory, I have been facing migration overhead esp. TLB shootdown on promotion or demotion between different tiers. Yeah.. most TLB shootdowns on migration through hinting fault can be avoided thanks to Huang Ying's work, commit 4d4b6d66db ("mm,unmap: avoid flushing TLB in batch if PTE is inaccessible"). See the following link:
https://lore.kernel.org/lkml/[email protected]/
However, it's only for ones using hinting fault. I thought it'd be much better if we have a general mechanism to reduce the number of TLB flushes and TLB misses, that we can apply to any type of migration. I tried it only for tiering migration for now tho.
I'm suggesting a mechanism to reduce TLB flushes by keeping source and destination of folios participated in the migrations until all TLB flushes required are done, only if those folios are not mapped with write permission PTE entries at all. I worked Based on v6.7.
I saw the number of iTLB full flush was reduced by 94%, iTLB miss was reduced by 45.5% and the total runtime was reduced by 3.5% with the workload I tested with, XSBench. However, I believe that it would help more with other ones or any real ones. It'd be appreciated to let me know if I'm missing something.
Byungchul
---
Changes from v6:
1. Fix build errors in case of CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH disabled by moving migrc_flush_{start,end}() calls from arch code to try_to_unmap_flush() in mm/rmap.c.
Changes from v5:
1. Fix build errors in case of CONFIG_MIGRATION disabled or CONFIG_HWPOISON_INJECT moduled. (feedbacked by kernel test bot and Raymond Jay Golo)
2. Organize migrc code with two kconfigs, CONFIG_MIGRATION and CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH.
Changes from v4:
1. Rebase on v6.7.
2. Fix build errors in arm64 that is doing nothing for TLB flush but has CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH. (reported by kernel test robot)
3. Don't use any page flag. So the system would give up migrc mechanism more often but it's okay. The final improvement is good enough.
4. Instead, optimize full TLB flush(arch_tlbbatch_flush()) by avoiding redundant CPUs from TLB flush.
Changes from v3:
1. Don't use the kconfig, CONFIG_MIGRC, and remove sysctl knob, migrc_enable. (feedbacked by Nadav)
2. Remove the optimization skipping CPUs that have already performed TLB flushes needed by any reason when performing TLB flushes by migrc because I can't tell the performance difference between w/ the optimization and w/o that. (feedbacked by Nadav)
3. Minimize arch-specific code. While at it, move all the migrc declarations and inline functions from include/linux/mm.h to mm/internal.h (feedbacked by Dave Hansen, Nadav)
4. Separate a part making migrc paused when the system is in high memory pressure to another patch. (feedbacked by Nadav)
5. Rename:
a. arch_tlbbatch_clean() to arch_tlbbatch_clear(), b. tlb_ubc_nowr to tlb_ubc_ro,
c. migrc_try_flush_free_folios() to migrc_flush_free_folios(), d. migrc_stop to migrc_pause.
(feedbacked by Nadav)
6. Use ->lru list_head instead of introducing a new llist_head. (feedbacked by Nadav)
7. Use non-atomic operations of page-flag when it's safe. (feedbacked by Nadav)
8. Use stack instead of keeping a pointer of 'struct migrc_req' in struct task, which is for manipulating it locally. (feedbacked by Nadav)
9. Replace a lot of simple functions to inline functions placed in a header, mm/internal.h. (feedbacked by Nadav)
10. Add additional sufficient comments. (feedbacked by Nadav)
11. Remove a lot of wrapper functions. (feedbacked by Nadav)
Changes from RFC v2:
1. Remove additional occupation in struct page. To do that, unioned with lru field for migrc's list and added a page flag. I know page flag is a thing that we don't like to add but no choice because migrc should distinguish folios under migrc's control from others. Instead, I force migrc to be used only on 64 bit system to mitigate you guys from getting angry.
2. Remove meaningless internal object allocator that I introduced to minimize impact onto the system. However, a ton of tests showed there was no difference.
3. Stop migrc from working when the system is in high memory pressure like about to perform direct reclaim. At the condition where the swap mechanism is heavily used, I found the system suffered from regression without this control.
4. Exclude folios that pte_dirty() == true from migrc's interest so that migrc can work simpler.
5. Combine several patches that work tightly coupled to one.
6. Add sufficient comments for better review.
7. Manage migrc's request in per-node manner (from globally).
8. Add TLB miss improvement in commit message.
9. Test with more CPUs(4 -> 16) to see bigger improvement.
Changes from RFC:
1. Fix a bug triggered when a destination folio at the previous migration becomes a source folio at the next migration, before the folio gets handled properly so that the folio can play with another migration. There was inconsistency in the folio's state. Fixed it.
2. Split the patch set into more pieces so that the folks can review better. (Feedbacked by Nadav Amit)
3. Fix a wrong usage of barrier e.g. smp_mb__after_atomic(). (Feedbacked by Nadav Amit)
4. Tried to add sufficient comments to explain the patch set better. (Feedbacked by Nadav Amit)
Byungchul Park (8):
x86/tlb: Add APIs manipulating tlb batch's arch data
arm64: tlbflush: Add APIs manipulating tlb batch's arch data mm/rmap: Recognize read-only TLB entries during batched TLB flush x86/tlb, mm/rmap: Separate arch_tlbbatch_clear() out of
arch_tlbbatch_flush()
mm: Separate move/undo doing on folio list from migrate_pages_batch()
mm: Add APIs to free a folio directly to the buddy bypassing pcp
mm: Defer TLB flush by keeping both src and dst folios at migration
mm: Pause migrc mechanism at high memory pressure
arch/arm64/include/asm/tlbflush.h | 19 ++ arch/x86/include/asm/tlbflush.h | 18 ++ arch/x86/mm/tlb.c | 2 - include/linux/mm.h | 23 ++ include/linux/mmzone.h | 7 + include/linux/sched.h | 9 + mm/internal.h | 78 ++++++ mm/memory.c | 8 + mm/migrate.c | 411 ++++++++++++++++++++++++++---- mm/page_alloc.c | 34 ++- mm/rmap.c | 40 ++- mm/swap.c | 7 + 12 files changed, 597 insertions(+), 59 deletions(-)
base-commit: 0dd3ee31125508cd67f7e7172247f05b7fd1753a
Signature · 1 line
2.17.1
Byungchul Park
reviewerPATCH RESEND v7 1/8 x86/tlb: Add APIs manipulating tlb batch's arch data
This is a preparation for migrc mechanism that needs to recognize read-only TLB entries during batched TLB flush by separating tlb batch's arch data into two, one is for read-only entries and the other is for writable ones, and merging those two when needed.
Migrc also needs to optimize CPUs to flush by clearing ones that have already performed TLB flush needed.
To support it, added APIs manipulating arch data for x86.
--- arch/x86/include/asm/tlbflush.h | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
arch/x86/include/asm/tlbflush.h +18 -0
@@ -5,6 +5,7 @@#include <linux/mm_types.h> #include <linux/mmu_notifier.h> #include <linux/sched.h> +#include <linux/cpumask.h> #include <asm/processor.h> #include <asm/cpufeature.h>
@@ -293,6 +294,23 @@ static inline void arch_flush_tlb_batched_pending(struct mm_struct *mm)extern void arch_tlbbatch_flush (struct arch_tlbflush_unmap_batch *batch); +static inline void arch_tlbbatch_clear (struct arch_tlbflush_unmap_batch *batch) +{ +cpumask_clear (&batch->cpumask); +} + +static inline void arch_tlbbatch_fold (struct arch_tlbflush_unmap_batch *bdst, +struct arch_tlbflush_unmap_batch *bsrc) +{ +cpumask_or (&bdst->cpumask, &bdst->cpumask, &bsrc->cpumask); +} + +static inline bool arch_tlbbatch_done (struct arch_tlbflush_unmap_batch *bdst, +struct arch_tlbflush_unmap_batch *bsrc) +{ +return cpumask_andnot (&bdst->cpumask, &bdst->cpumask, &bsrc->cpumask); +} +static inline bool pte_flags_need_flush (unsigned long oldflags,unsigned long newflags,bool ignore_access)
Signature · 1 line
2.17.1
Byungchul Park
reviewerPATCH RESEND v7 2/8 arm64: tlbflush: Add APIs manipulating tlb batch's arch data
In reply to Byungchul ParkThis is a preparation for migrc mechanism that requires to manipulate tlb batch's arch data. Even though arm64 does nothing with it, arch with CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH should provide the APIs.
--- arch/arm64/include/asm/tlbflush.h | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
arch/arm64/include/asm/tlbflush.h +19 -0
@@ -328,6 +328,25 @@ static inline void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch)dsb (ish); } +static inline void arch_tlbbatch_clear (struct arch_tlbflush_unmap_batch *batch) +{ +/* nothing to do */ +} + +static inline void arch_tlbbatch_fold (struct arch_tlbflush_unmap_batch *bdst, +struct arch_tlbflush_unmap_batch *bsrc) +{ +/* nothing to do */ +} + +static inline bool arch_tlbbatch_done (struct arch_tlbflush_unmap_batch *bdst, +struct arch_tlbflush_unmap_batch *bsrc) +{ +/* nothing to do */ + +return false; +} +/* * This is meant to avoid soft lock-ups on large TLB flushing ranges and not * necessarily a performance improvement.
Signature · 1 line
2.17.1
Byungchul Park
reviewerPATCH RESEND v7 3/8 mm/rmap: Recognize read-only TLB entries during batched TLB flush
In reply to Byungchul ParkFunctionally, no change. This is a preparation for migrc mechanism that requires to recognize read-only TLB entries and makes use of them to batch more aggressively. Plus, the newly introduced API, fold_ubc() will be used by migrc mechanism when manipulating tlb batch data.
--- include/linux/sched.h | 1 + mm/internal.h | 4 ++++ mm/rmap.c | 31 ++++++++++++++++++++++++++++++- 3 files changed, 35 insertions(+), 1 deletion(-)
include/linux/sched.h +1 -0
@@ -1328,6 +1328,7 @@ struct task_struct {#endif struct tlbflush_unmap_batch tlb_ubc; +struct tlbflush_unmap_batch tlb_ubc_ro;/* Cache last used pipe for splice(): */ struct pipe_inode_info *splice_pipe;
mm/internal.h +4 -0
@@ -923,6 +923,7 @@ extern struct workqueue_struct *mm_percpu_wq;void try_to_unmap_flush (void );void try_to_unmap_flush_dirty (void );void flush_tlb_batched_pending (struct mm_struct *mm); +void fold_ubc (struct tlbflush_unmap_batch *dst,struct tlbflush_unmap_batch *src);#else static inline void try_to_unmap_flush (void ) {
@@ -933,6 +934,9 @@ static inline void try_to_unmap_flush_dirty(void)static inline void flush_tlb_batched_pending (struct mm_struct *mm) { } +static inline void fold_ubc (struct tlbflush_unmap_batch *dst,struct tlbflush_unmap_batch *src) +{ +}#endif /* CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH */ extern const struct trace_print_flags pageflag_names[];
mm/rmap.c +30 -1
@@ -605,6 +605,28 @@ struct anon_vma *folio_lock_anon_vma_read(struct folio *folio, }#ifdef CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH + +void fold_ubc (struct tlbflush_unmap_batch *dst, +struct tlbflush_unmap_batch *src) +{ +if (!src->flush_required) +return ; + +/* +* Fold src to dst. +*/ +arch_tlbbatch_fold (&dst->arch, &src->arch); + dst->writable = dst->writable || src->writable; + dst->flush_required = true; + +/* +* Reset src. +*/ +arch_tlbbatch_clear (&src->arch); + src->flush_required = false; + src->writable = false; +} +/* * Flush TLB entries for recently unmapped pages from remote CPUs. It is * important if a PTE was dirty when it was unmapped that it's flushed
@@ -614,7 +636,9 @@ struct anon_vma *folio_lock_anon_vma_read(struct folio *folio,void try_to_unmap_flush (void ) {struct tlbflush_unmap_batch *tlb_ubc = ¤t->tlb_ubc; +struct tlbflush_unmap_batch *tlb_ubc_ro = ¤t->tlb_ubc_ro; +fold_ubc (tlb_ubc, tlb_ubc_ro);if (!tlb_ubc->flush_required)return ;
@@ -645,13 +669,18 @@ void try_to_unmap_flush_dirty(void)static void set_tlb_ubc_flush_pending (struct mm_struct *mm,pte_t pteval,unsigned long uaddr) { -struct tlbflush_unmap_batch *tlb_ubc = ¤t->tlb_ubc; +struct tlbflush_unmap_batch *tlb_ubc;int batch;bool writable =pte_dirty (pteval);if (!pte_accessible (mm, pteval))return ; +if (pte_write (pteval) || writable) + tlb_ubc = ¤t->tlb_ubc; +else + tlb_ubc = ¤t->tlb_ubc_ro; +arch_tlbbatch_add_pending (&tlb_ubc->arch, mm, uaddr); tlb_ubc->flush_required = true;
Signature · 1 line
2.17.1
Byungchul Park
reviewerPATCH RESEND v7 4/8 x86/tlb, mm/rmap: Separate arch_tlbbatch_clear() out of arch_tlbbatch_flush()
In reply to Byungchul ParkThis is a preparation for migrc mechanism that requires to avoid redundant TLB flushes by manipulating tlb batch's arch data after arch_tlbbatch_flush(). However, we cannot because the data is getting cleared inside arch_tlbbatch_flush(). So separated the part clearing the tlb batch's arch data out of arch_tlbbatch_flush().
--- arch/x86/mm/tlb.c | 2 -- mm/rmap.c | 1 + 2 files changed, 1 insertion(+), 2 deletions(-)
arch/x86/mm/tlb.c +0 -2
@@ -1268,8 +1268,6 @@ void arch_tlbbatch_flush(struct arch_tlbflush_unmap_batch *batch)local_irq_enable (); } -cpumask_clear (&batch->cpumask); -put_flush_tlb_info ();put_cpu (); }
mm/rmap.c +1 -0
@@ -643,6 +643,7 @@ void try_to_unmap_flush(void)return ;arch_tlbbatch_flush (&tlb_ubc->arch); +arch_tlbbatch_clear (&tlb_ubc->arch); tlb_ubc->flush_required = false; tlb_ubc->writable = false; }
Signature · 1 line
2.17.1
Byungchul Park
reviewerPATCH RESEND v7 5/8 mm: Separate move/undo doing on folio list from migrate_pages_batch()
In reply to Byungchul ParkFunctionally, no change. This is a preparation for migrc mechanism that requires to use separate folio lists for its own handling at migration.
Refactored migrate_pages_batch() and separated move and undo parts operating on folio list, from migrate_pages_batch().
--- mm/migrate.c | 134 +++++++++++++++++++++++++++++++-------------------- 1 file changed, 83 insertions(+), 51 deletions(-)
mm/migrate.c +83 -51
@@ -1611,6 +1611,81 @@ static int migrate_hugetlbs(struct list_head *from, new_folio_t get_new_folio,return nr_failed; } +static void migrate_folios_move (struct list_head *src_folios, +struct list_head *dst_folios, +free_folio_t put_new_folio,unsigned long private, +enum migrate_mode mode,int reason, +struct list_head *ret_folios, +struct migrate_pages_stats *stats, +int *retry,int *thp_retry,int *nr_failed, +int *nr_retry_pages) +{ +struct folio *folio, *folio2, *dst, *dst2; +bool is_thp; +int nr_pages; +int rc; + + dst = list_first_entry(dst_folios, struct folio, lru); + dst2 =list_next_entry (dst, lru); +list_for_each_entry_safe (folio, folio2, src_folios, lru) { + is_thp =folio_test_large (folio) &&folio_test_pmd_mappable (folio); + nr_pages =folio_nr_pages (folio); + +cond_resched (); + + rc =migrate_folio_move (put_new_folio, private, + folio, dst, mode, + reason, ret_folios); +/* +* The rules are: +* Success: folio will be freed +* -EAGAIN: stay on the unmap_folios list +* Other errno: put on ret_folios list +*/ +switch (rc) { +case -EAGAIN : + *retry +=1 ; + *thp_retry += is_thp; + *nr_retry_pages += nr_pages; +break ; +case MIGRATEPAGE_SUCCESS : + stats->nr_succeeded += nr_pages; + stats->nr_thp_succeeded += is_thp; +break ; +default : + *nr_failed +=1 ; + stats->nr_thp_failed += is_thp; + stats->nr_failed_pages += nr_pages; +break ; + } + dst = dst2; + dst2 =list_next_entry (dst, lru); + } +} + +static void migrate_folios_undo (struct list_head *src_folios, +struct list_head *dst_folios, +free_folio_t put_new_folio,unsigned long private, +struct list_head *ret_folios) +{ +struct folio *folio, *folio2, *dst, *dst2; + + dst = list_first_entry(dst_folios, struct folio, lru); + dst2 =list_next_entry (dst, lru); +list_for_each_entry_safe (folio, folio2, src_folios, lru) { +int old_page_state =0 ; +struct anon_vma *anon_vma =NULL ; + +__migrate_folio_extract (dst, &old_page_state, &anon_vma); +migrate_folio_undo_src (folio, old_page_state &PAGE_WAS_MAPPED , + anon_vma, true, ret_folios); +list_del (&dst->lru); +migrate_folio_undo_dst (dst, true, put_new_folio, private); + dst = dst2; + dst2 =list_next_entry (dst, lru); + } +} +/* * migrate_pages_batch() first unmaps folios in the from list as many as * possible, then move the unmapped folios.
@@ -1633,7 +1708,7 @@ static int migrate_pages_batch(struct list_head *from,int pass =0 ;bool is_thp = false;bool is_large = false; -struct folio *folio, *folio2, *dst =NULL , *dst2; +struct folio *folio, *folio2, *dst =NULL ;int rc, rc_saved =0 , nr_pages;LIST_HEAD (unmap_folios);LIST_HEAD (dst_folios);
@@ -1769,42 +1844,11 @@ static int migrate_pages_batch(struct list_head *from, thp_retry =0 ; nr_retry_pages =0 ; - dst = list_first_entry(&dst_folios, struct folio, lru); - dst2 =list_next_entry (dst, lru); -list_for_each_entry_safe (folio, folio2, &unmap_folios, lru) { - is_thp =folio_test_large (folio) &&folio_test_pmd_mappable (folio); - nr_pages =folio_nr_pages (folio); - -cond_resched (); - - rc =migrate_folio_move (put_new_folio, private, - folio, dst, mode, - reason, ret_folios); -/* -* The rules are: -* Success: folio will be freed -* -EAGAIN: stay on the unmap_folios list -* Other errno: put on ret_folios list -*/ -switch (rc) { -case -EAGAIN : - retry++; - thp_retry += is_thp; - nr_retry_pages += nr_pages; -break ; -case MIGRATEPAGE_SUCCESS : - stats->nr_succeeded += nr_pages; - stats->nr_thp_succeeded += is_thp; -break ; -default : - nr_failed++; - stats->nr_thp_failed += is_thp; - stats->nr_failed_pages += nr_pages; -break ; - } - dst = dst2; - dst2 =list_next_entry (dst, lru); - } +/* Move the unmapped folios */ +migrate_folios_move (&unmap_folios, &dst_folios, + put_new_folio, private, mode, reason, + ret_folios, stats, &retry, &thp_retry, + &nr_failed, &nr_retry_pages); } nr_failed += retry; stats->nr_thp_failed += thp_retry;
@@ -1813,20 +1857,8 @@ static int migrate_pages_batch(struct list_head *from, rc = rc_saved ? : nr_failed; out:/* Cleanup remaining folios */ - dst = list_first_entry(&dst_folios, struct folio, lru); - dst2 =list_next_entry (dst, lru); -list_for_each_entry_safe (folio, folio2, &unmap_folios, lru) { -int old_page_state =0 ; -struct anon_vma *anon_vma =NULL ; - -__migrate_folio_extract (dst, &old_page_state, &anon_vma); -migrate_folio_undo_src (folio, old_page_state &PAGE_WAS_MAPPED , - anon_vma, true, ret_folios); -list_del (&dst->lru); -migrate_folio_undo_dst (dst, true, put_new_folio, private); - dst = dst2; - dst2 =list_next_entry (dst, lru); - } +migrate_folios_undo (&unmap_folios, &dst_folios, + put_new_folio, private, ret_folios);return rc; }
Signature · 1 line
2.17.1
Byungchul Park
reviewerPATCH RESEND v7 6/8 mm: Add APIs to free a folio directly to the buddy bypassing pcp
In reply to Byungchul ParkThis is a preparation for migrc mechanism that frees folios at a better time later, rather than the moment migrating folios. The folios freed by migrc are too old to keep in pcp.
--- include/linux/mm.h | 23 +++++++++++++++++++++++ mm/internal.h | 1 + mm/page_alloc.c | 10 ++++++++++ mm/swap.c | 7 +++++++ 4 files changed, 41 insertions(+)
include/linux/mm.h +23 -0
@@ -1284,6 +1284,7 @@ static inline struct folio *virt_to_folio(const void *x) }void __folio_put (struct folio *folio); +void __folio_put_small_nopcp (struct folio *folio);void put_pages_list (struct list_head *pages);
@@ -1483,6 +1484,28 @@ static inline void folio_put(struct folio *folio)__folio_put (folio); } +/** +* folio_put_small_nopcp - Decrement the reference count on a folio. +* @folio: The folio. +* +* This is only for a single page folio to release directly to the buddy +* allocator bypassing pcp. +* +* If the folio's reference count reaches zero, the memory will be +* released back to the page allocator and may be used by another +* allocation immediately. Do not access the memory or the struct folio +* after calling folio_put_small_nopcp() unless you can be sure that it +* wasn't the last reference. +* +* Context: May be called in process or interrupt context, but not in NMI +* context. May be called while holding a spinlock. +*/ +static inline void folio_put_small_nopcp (struct folio *folio) +{ +if (folio_put_testzero (folio)) +__folio_put_small_nopcp (folio); +} +/** * folio_put_refs - Reduce the reference count on a folio. * @folio: The folio.
mm/internal.h +1 -0
@@ -451,6 +451,7 @@ extern int user_min_free_kbytes;extern void free_unref_page (struct page *page,unsigned int order);extern void free_unref_page_list (struct list_head *list); +extern void free_pages_nopcp (struct page *page,unsigned int order);extern void zone_pcp_reset (struct zone *zone);extern void zone_pcp_disable (struct zone *zone);
mm/page_alloc.c +10 -0
@@ -565,6 +565,16 @@ static inline void free_the_page(struct page *page, unsigned int order)__free_pages_ok (page, order,FPI_NONE ); } +void free_pages_nopcp (struct page *page,unsigned int order) +{ +/* +* This function will be used in case that the pages are too +* cold to keep in pcp e.g. migrc mechanism. So it'd better +* release the pages to the tail. +*/ +__free_pages_ok (page, order,FPI_TO_TAIL ); +} +/* * Higher-order pages are called "compound pages". They are structured thusly: *
mm/swap.c +7 -0
@@ -106,6 +106,13 @@ static void __folio_put_small(struct folio *folio)free_unref_page (&folio->page,0 ); } +void __folio_put_small_nopcp (struct folio *folio) +{ +__page_cache_release (folio); +mem_cgroup_uncharge (folio); +free_pages_nopcp (&folio->page,0 ); +} +static void __folio_put_large (struct folio *folio) {/*
Signature · 1 line
2.17.1
Andrew Morton
maintainerRe: [RESEND PATCH v7 6/8] mm: Add APIs to free a folio directly to the buddy bypassing pcp
Quoted 1 line · On Thu, 8 Feb 2024 15:26:06 +0900 Byungchul Park <[email protected]> wrote:
This is a preparation for migrc mechanism that frees folios at a better
The term "migrc" appears in various places but I don't think we're told what is actually means?
Quoted 2 lines
time later, rather than the moment migrating folios. The folios freed by migrc are too old to keep in pcp.
How do we define "too old" and what causes you to believe this is the case?
Byungchul Park
reviewerRe: [RESEND PATCH v7 6/8] mm: Add APIs to free a folio directly to the buddy bypassing pcp
Quoted 11 lines · Andrew Morton
Quoted 1 line · On Thu, 8 Feb 2024 15:26:06 +0900 Byungchul Park <[email protected]> wrote:
This is a preparation for migrc mechanism that frees folios at a better
The term "migrc" appears in various places but I don't think we're told what is actually means?
Quoted 2 lines
time later, rather than the moment migrating folios. The folios freed by migrc are too old to keep in pcp.
How do we define "too old" and what causes you to believe this is the case?
Migrc defers folio_put() for source folios of migration that would be unlikely used and frees a bunch of folios at once later. However, it pollutes pcp, which means fresher folios might get free_pcppages_bulk()ed and makes the effort to keep the best amount of pcp get unstable. So I didn't want to make this situation happen.
Byungchul
Byungchul Park
reviewerPATCH RESEND v7 7/8 mm: Defer TLB flush by keeping both src and dst folios at migration
In reply to Byungchul ParkImplementation of MIGRC mechanism that stands for 'Migration Read Copy'. We always face the migration overhead at either promotion or demotion, while working with tiered memory e.g. CXL memory and found out TLB shootdown is a quite big one that is needed to get rid of if possible.
Fortunately, TLB flush can be defered if both source and destination of folios during migration are kept until all TLB flushes required will have been done, of course, only if the target PTE entries have read-only permission, more precisely speaking, don't have write permission. Otherwise, no doubt the folio might get messed up.
To achieve that:
1. For the folios that map only to non-writable TLB entries, prevent TLB flush at migration by keeping both source and destination folios, which will be handled later at a better time.
2. When any non-writable TLB entry changes to writable e.g. through fault handler, give up migrc mechanism so as to perform TLB flush required right away.
The following evaluation using XSBench shows the improvement like:
1. itlb flush was reduced by 93.9%.
2. dtlb thread was reduced by 43.5%.
3. stlb flush was reduced by 24.9%.
4. dtlb store misses was reduced by 34.2%.
5. itlb load misses was reduced by 45.5%.
6. The runtime was reduced by 3.5%.
---
The measurement result:
Architecture - x86_64
QEMU - kvm enabled, host cpu
Numa - 2 nodes (16 CPUs 1GB, no CPUs 8GB)
Linux Kernel - v6.7, numa balancing tiering on, demotion enabled Benchmark - XSBench -p 100000000 (-p option makes the runtime longer)
run 'perf stat' using events:
1) itlb.itlb_flush
2) tlb_flush.dtlb_thread
3) tlb_flush.stlb_any
4) dTLB-load-misses
5) dTLB-store-misses
6) iTLB-load-misses
run 'cat /proc/vmstat' and pick:
1) numa_pages_migrated
2) pgmigrate_success
3) nr_tlb_remote_flush
4) nr_tlb_remote_flush_received
5) nr_tlb_local_flush_all
6) nr_tlb_local_flush_one
BEFORE - mainline v6.7
------------------------------------------
$ perf stat -a \ -e itlb.itlb_flush \ -e tlb_flush.dtlb_thread \ -e tlb_flush.stlb_any \ -e dTLB-load-misses \ -e dTLB-store-misses \ -e iTLB-load-misses \ ./XSBench -p 100000000
Performance counter stats for 'system wide':
85647229 itlb.itlb_flush
480981504 tlb_flush.dtlb_thread
323937200 tlb_flush.stlb_any
238381632579 dTLB-load-misses
601514255 dTLB-store-misses
2974157461 iTLB-load-misses2252.883892112 seconds time elapsed
$ cat /proc/vmstat
...
numa_pages_migrated 12790664
pgmigrate_success 26835314
nr_tlb_remote_flush 3031412
nr_tlb_remote_flush_received 45234862
nr_tlb_local_flush_all 216584
nr_tlb_local_flush_one 740940
...
AFTER - mainline v6.7 + migrc
------------------------------------------
$ perf stat -a \ -e itlb.itlb_flush \ -e tlb_flush.dtlb_thread \ -e tlb_flush.stlb_any \ -e dTLB-load-misses \ -e dTLB-store-misses \ -e iTLB-load-misses \ ./XSBench -p 100000000
Performance counter stats for 'system wide':
5240261 itlb.itlb_flush
271581774 tlb_flush.dtlb_thread
243149389 tlb_flush.stlb_any
234502983364 dTLB-load-misses
395673680 dTLB-store-misses
1620215163 iTLB-load-misses2172.283436287 seconds time elapsed
$ cat /proc/vmstat
...
numa_pages_migrated 14897064
pgmigrate_success 30825530
nr_tlb_remote_flush 198290
nr_tlb_remote_flush_received 2820156
nr_tlb_local_flush_all 92048
nr_tlb_local_flush_one 741401
...
--- include/linux/mmzone.h | 7 ++ include/linux/sched.h | 8 ++ mm/internal.h | 53 ++++++++ mm/memory.c | 8 ++ mm/migrate.c | 271 +++++++++++++++++++++++++++++++++++++++-- mm/page_alloc.c | 11 +- mm/rmap.c | 12 +- 7 files changed, 358 insertions(+), 12 deletions(-)
include/linux/mmzone.h +7 -0
@@ -1002,6 +1002,13 @@ struct zone {/* Zone statistics */ atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS ];atomic_long_t vm_numa_event[NR_VM_NUMA_EVENT_ITEMS ]; + +#if defined(CONFIG_MIGRATION ) && defined(CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH ) +/* +* the number of folios pending for TLB flush in the zone +*/ +atomic_t migrc_pending_nr; +#endif }____cacheline_internodealigned_in_smp ;enum pgdat_flags {
include/linux/sched.h +8 -0
@@ -1330,6 +1330,14 @@ struct task_struct {struct tlbflush_unmap_batch tlb_ubc;struct tlbflush_unmap_batch tlb_ubc_ro; +#if defined(CONFIG_MIGRATION ) && defined(CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH ) +/* +* whether all the mappings of a folio during unmap are read-only +* so that migrc can work on the folio +*/ +bool can_migrc; +#endif +/* Cache last used pipe for splice(): */ struct pipe_inode_info *splice_pipe;
mm/internal.h +53 -0
57 lines not on this page · raw message
mm/memory.c +8 -0
@@ -3462,6 +3462,14 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)if (vmf->page) folio =page_folio (vmf->page); +/* +* The folio may or may not be one that is under migrc's control +* and about to change its permission from read-only to writable. +* Conservatively give up deferring TLB flush just in case. +*/ +if (folio) +migrc_flush_free_folios (); +/* * Shared mapping: we are guaranteed to have VM_WRITE and * FAULT_FLAG_WRITE set at this point.
mm/migrate.c +262 -9
364 lines not on this page · raw message
mm/page_alloc.c +10 -1
@@ -2972,6 +2972,8 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,long min = mark;int o; + free_pages +=migrc_pending_nr_in_zone (z); +/* free_pages may go negative - that's OK */ free_pages -=__zone_watermark_unusable_free (z, order, alloc_flags);
@@ -3066,7 +3068,7 @@ static inline bool zone_watermark_fast(struct zone *z, unsigned int order,long usable_free;long reserved; - usable_free = free_pages; + usable_free = free_pages +migrc_pending_nr_in_zone (z); reserved =__zone_watermark_unusable_free (z,0 , alloc_flags);/* reserved may over estimate high-atomic reserves. */
@@ -3273,6 +3275,13 @@ get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags, gfp_mask)) {int ret; +if (migrc_pending_nr_in_zone (zone) && +migrc_flush_free_folios () && +zone_watermark_fast (zone, order, mark, + ac->highest_zoneidx, + alloc_flags, gfp_mask)) + goto try_this_zone; +if (has_unaccepted_memory ()) {if (try_to_accept_memory (zone, order)) goto try_this_zone;
mm/rmap.c +10 -2
@@ -642,7 +642,9 @@ void try_to_unmap_flush(void)if (!tlb_ubc->flush_required)return ; +migrc_flush_start ();arch_tlbbatch_flush (&tlb_ubc->arch); +migrc_flush_end (tlb_ubc);arch_tlbbatch_clear (&tlb_ubc->arch); tlb_ubc->flush_required = false; tlb_ubc->writable = false;
@@ -677,9 +679,15 @@ static void set_tlb_ubc_flush_pending(struct mm_struct *mm, pte_t pteval,if (!pte_accessible (mm, pteval))return ; -if (pte_write (pteval) || writable) +if (pte_write (pteval) || writable) { tlb_ubc = ¤t->tlb_ubc; -else + +/* +* Migrc cannot work with the folio, once it found a +* writable or dirty mapping on it. +*/ +can_migrc_fail (); + }else tlb_ubc = ¤t->tlb_ubc_ro;arch_tlbbatch_add_pending (&tlb_ubc->arch, mm, uaddr);
Signature · 1 line
2.17.1
Andrew Morton
maintainerRe: [RESEND PATCH v7 7/8] mm: Defer TLB flush by keeping both src and dst folios at migration
Quoted 1 line · On Thu, 8 Feb 2024 15:26:07 +0900 Byungchul Park <[email protected]> wrote:
Implementation of MIGRC mechanism that stands for 'Migration Read Copy'.
Oh there is it. Please put this in the [0/N] cover letter?
Byungchul Park
reviewerRe: [RESEND PATCH v7 7/8] mm: Defer TLB flush by keeping both src and dst folios at migration
Quoted 5 lines · Andrew Morton
Quoted 1 line · On Thu, 8 Feb 2024 15:26:07 +0900 Byungchul Park <[email protected]> wrote:
Implementation of MIGRC mechanism that stands for 'Migration Read Copy'.
Oh there is it. Please put this in the [0/N] cover letter?
Sure. I should've put this in the cover letter. Thanks.
Byungchul
Byungchul Park
reviewerPATCH RESEND v7 8/8 mm: Pause migrc mechanism at high memory pressure
In reply to Byungchul ParkRegression was observed when the system is in high memory pressure with swap on, where migrc might keep a number of folios in its pending queue, which possibly makes it worse. So temporarily prevented migrc from working on that condition.
--- mm/internal.h | 20 ++++++++++++++++++++ mm/migrate.c | 18 +++++++++++++++++- mm/page_alloc.c | 13 +++++++++++++ 3 files changed, 50 insertions(+), 1 deletion(-)
mm/internal.h +20 -0
@@ -1285,6 +1285,8 @@ static inline void shrinker_debugfs_remove(struct dentry *debugfs_entry,#endif /* CONFIG_SHRINKER_DEBUG */ #if defined(CONFIG_MIGRATION ) && defined(CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH ) +extern atomic_t migrc_pause_cnt; +/* * Reset the indicator indicating there are no writable mappings at the * beginning of every rmap traverse for unmap. Migrc can work only when
@@ -1313,6 +1315,21 @@ static inline bool can_migrc_test(void)return current->can_migrc && current->tlb_ubc_ro.flush_required; } +static inline void migrc_pause (void ) +{ +atomic_inc (&migrc_pause_cnt); +} + +static inline void migrc_resume (void ) +{ +atomic_dec (&migrc_pause_cnt); +} + +static inline bool migrc_paused (void ) +{ +return !!atomic_read (&migrc_pause_cnt); +} +/* * Return the number of folios pending TLB flush that have yet to get * freed in the zone.
@@ -1332,6 +1349,9 @@ void migrc_flush_end(struct tlbflush_unmap_batch *batch);static inline void can_migrc_init (void ) {}static inline void can_migrc_fail (void ) {}static inline bool can_migrc_test (void ) {return false; } +static inline void migrc_pause (void ) {} +static inline void migrc_resume (void ) {} +static inline bool migrc_paused (void ) {return false; }static inline int migrc_pending_nr_in_zone (struct zone *z) {return 0 ; }static inline bool migrc_flush_free_folios (void ) {return false; }static inline void migrc_flush_start (void ) {}
mm/migrate.c +17 -1
@@ -62,6 +62,12 @@ static struct tlbflush_unmap_batch migrc_ubc;static LIST_HEAD (migrc_folios);static DEFINE_SPINLOCK (migrc_lock); +/* +* Increase on entry of handling high memory pressure e.g. direct +* reclaim, decrease on the exit. See __alloc_pages_slowpath(). +*/ +atomic_t migrc_pause_cnt =ATOMIC_INIT (0 ); +static void init_tlb_ubc (struct tlbflush_unmap_batch *ubc) {arch_tlbbatch_clear (&ubc->arch);
@@ -1922,7 +1928,8 @@ static int migrate_pages_batch(struct list_head *from,*/ init_tlb_ubc (&pending_ubc); do_migrc =IS_ENABLED (CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH ) && - (reason ==MR_DEMOTION || reason ==MR_NUMA_MISPLACED ); + (reason ==MR_DEMOTION || reason ==MR_NUMA_MISPLACED ) && + !migrc_paused ();for (pass =0 ; pass < nr_pass && retry; pass++) { retry =0 ;
@@ -1961,6 +1968,15 @@ static int migrate_pages_batch(struct list_head *from,continue ; } +/* +* In case that the system is in high memory +* pressure, give up migrc mechanism this turn. +*/ +if (unlikely (do_migrc &&migrc_paused ())) { +fold_ubc (tlb_ubc, &pending_ubc); + do_migrc = false; + } +can_migrc_init (); rc = migrate_folio_unmap(get_new_folio, put_new_folio, private, folio, &dst, mode, reason,
mm/page_alloc.c +13 -0
@@ -4072,6 +4072,7 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,unsigned int cpuset_mems_cookie;unsigned int zonelist_iter_cookie;int reserve_flags; +bool migrc_paused = false; restart: compaction_retries =0 ;
@@ -4203,6 +4204,16 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,if (page) goto got_pg; +/* +* The system is in very high memory pressure. Pause migrc from +* expanding its pending queue temporarily. +*/ +if (!migrc_paused) { +migrc_pause (); + migrc_paused = true; +migrc_flush_free_folios (); + } +/* Caller is not willing to reclaim, we can't balance anything */ if (!can_direct_reclaim) goto nopage;
@@ -4330,6 +4341,8 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,warn_alloc (gfp_mask, ac->nodemask,"page allocation failure: order:%u" , order); got_pg: +if (migrc_paused) +migrc_resume ();return page; }
Signature · 1 line
2.17.1