mm: avoid extra mem_alloc_profiling_enabled() checks
Subsystems (5)
Suren Baghdasaryan
maintainerPATCH v2 1/3 mm: avoid extra mem_alloc_profiling_enabled() checks
Refactor code to avoid extra mem_alloc_profiling_enabled() checks inside pgalloc_tag_get() function which is often called after that check was already done.
--- include/linux/pgalloc_tag.h | 35 +++++++++++++++++++---------------- lib/alloc_tag.c | 6 +++--- mm/page_alloc.c | 3 +-- 3 files changed, 23 insertions(+), 21 deletions(-)
include/linux/pgalloc_tag.h +19 -16
@@ -205,28 +205,32 @@ static inline void pgalloc_tag_sub(struct page *page, unsigned int nr) } } -static inline struct alloc_tag *pgalloc_tag_get (struct page *page) +/* Should be called only if mem_alloc_profiling_enabled() */ +static inline struct alloc_tag *__pgalloc_tag_get (struct page *page) {struct alloc_tag *tag =NULL ; - -if (mem_alloc_profiling_enabled ()) { -union pgtag_ref_handle handle; -union codetag_ref ref; - -if (get_page_tag_ref (page, &ref, &handle)) { -alloc_tag_sub_check (&ref); -if (ref.ct) - tag =ct_to_alloc_tag (ref.ct); -put_page_tag_ref (handle); - } +union pgtag_ref_handle handle; +union codetag_ref ref; + +if (get_page_tag_ref (page, &ref, &handle)) { +alloc_tag_sub_check (&ref); +if (ref.ct) + tag =ct_to_alloc_tag (ref.ct); +put_page_tag_ref (handle); }return tag; } -static inline void pgalloc_tag_sub_pages (struct alloc_tag *tag,unsigned int nr) +static inline void pgalloc_tag_sub_pages (struct page *page,unsigned int nr) { -if (mem_alloc_profiling_enabled () && tag) +struct alloc_tag *tag; + +if (!mem_alloc_profiling_enabled ()) +return ; + + tag =__pgalloc_tag_get (page); +if (tag)this_cpu_sub (tag->counters->bytes,PAGE_SIZE * nr); }
@@ -241,8 +245,7 @@ static inline void clear_page_tag_ref(struct page *page) {}static inline void pgalloc_tag_add (struct page *page,struct task_struct *task,unsigned int nr) {}static inline void pgalloc_tag_sub (struct page *page,unsigned int nr) {} -static inline struct alloc_tag *pgalloc_tag_get (struct page *page) {return NULL ; } -static inline void pgalloc_tag_sub_pages (struct alloc_tag *tag,unsigned int nr) {} +static inline void pgalloc_tag_sub_pages (struct page *page,unsigned int nr) {}static inline void alloc_tag_sec_init (void ) {}static inline void pgalloc_tag_split (struct folio *folio,int old_order,int new_order) {}static inline void pgalloc_tag_swap (struct folio *new,struct folio *old) {}
lib/alloc_tag.c +3 -3
@@ -174,7 +174,7 @@ void pgalloc_tag_split(struct folio *folio, int old_order, int new_order)if (!mem_alloc_profiling_enabled ())return ; - tag =pgalloc_tag_get (&folio->page); + tag =__pgalloc_tag_get (&folio->page);if (!tag)return ;
@@ -200,10 +200,10 @@ void pgalloc_tag_swap(struct folio *new, struct folio *old)if (!mem_alloc_profiling_enabled ())return ; - tag_old =pgalloc_tag_get (&old->page); + tag_old =__pgalloc_tag_get (&old->page);if (!tag_old)return ; - tag_new =pgalloc_tag_get (&new->page); + tag_new =__pgalloc_tag_get (&new->page);if (!tag_new)return ;
mm/page_alloc.c +1 -2
@@ -4832,12 +4832,11 @@ void __free_pages(struct page *page, unsigned int order) {/* get PageHead before we drop reference */ int head =PageHead (page); -struct alloc_tag *tag =pgalloc_tag_get (page);if (put_page_testzero (page))free_frozen_pages (page, order);else if (!head) { -pgalloc_tag_sub_pages (tag, (1 << order) -1 ); +pgalloc_tag_sub_pages (page, (1 << order) -1 );while (order-- >0 )free_frozen_pages (page + (1 << order), order); }
base-commit: 7de6fd8ab65003f050aa58e705592745717ed318
Signature · 1 line
2.48.1.362.g079036d154-goog
Suren Baghdasaryan
maintainerPATCH v2 2/3 alloc_tag: uninline code gated by mem_alloc_profiling_key in slab allocator
When a sizable code section is protected by a disabled static key, that code gets into the instruction cache even though it's not executed and consumes the cache, increasing cache misses. This can be remedied by moving such code into a separate uninlined function.
On a Pixel6 phone, slab allocation profiling overhead measured with CONFIG_MEM_ALLOC_PROFILING=y and profiling disabled is:
baseline modified Big core 3.31% 0.17% Medium core 3.79% 0.57% Little core 6.68% 1.28%
This improvement comes at the expense of the configuration when profiling gets enabled, since there is now an additional function call. The overhead from this additional call on Pixel6 is:
Big core 0.66% Middle core 1.23% Little core 2.42%
However this is negligible when compared with the overall overhead of the memory allocation profiling when it is enabled.
On x86 this patch does not make noticeable difference because the overhead with mem_alloc_profiling_key disabled is much lower (under 1%) to start with, so any improvement is less visible and hard to distinguish from the noise. The overhead from additional call when profiling is enabled is also within noise levels.
---
Changes since v1 [1]:
- Removed inline_if_mem_alloc_prof and uninlined the gated code unconditionally, per Steven Rostedt and Vlastimil Babka
- Updated changelog to include overhead when profiling is enabled
[1] https://lore.kernel.org/all/[email protected]/
mm/slub.c | 51 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 32 insertions(+), 19 deletions(-)
mm/slub.c +32 -19
@@ -2000,7 +2000,8 @@ int alloc_slab_obj_exts(struct slab *slab, struct kmem_cache *s,return 0 ; } -static inline void free_slab_obj_exts (struct slab *slab) +/* Should be called only if mem_alloc_profiling_enabled() */ +static noinline void free_slab_obj_exts(struct slab *slab) {struct slabobj_ext *obj_exts;
@@ -2077,33 +2078,37 @@ prepare_slab_obj_exts_hook(struct kmem_cache *s, gfp_t flags, void *p)return slab_obj_exts (slab) +obj_to_index (s, slab, p); } -static inline void -alloc_tagging_slab_alloc_hook (struct kmem_cache *s,void *object,gfp_t flags) +/* Should be called only if mem_alloc_profiling_enabled() */ +static noinline void +__alloc_tagging_slab_alloc_hook (struct kmem_cache *s,void *object,gfp_t flags) { -if (need_slab_obj_ext ()) { -struct slabobj_ext *obj_exts; +struct slabobj_ext *obj_exts; - obj_exts =prepare_slab_obj_exts_hook (s, flags, object); -/* -* Currently obj_exts is used only for allocation profiling. -* If other users appear then mem_alloc_profiling_enabled() -* check should be added before alloc_tag_add(). -*/ -if (likely (obj_exts)) -alloc_tag_add (&obj_exts->ref, current->alloc_tag, s->size); - } + obj_exts =prepare_slab_obj_exts_hook (s, flags, object); +/* +* Currently obj_exts is used only for allocation profiling. +* If other users appear then mem_alloc_profiling_enabled() +* check should be added before alloc_tag_add(). +*/ +if (likely (obj_exts)) +alloc_tag_add (&obj_exts->ref, current->alloc_tag, s->size); }static inline void -alloc_tagging_slab_free_hook (struct kmem_cache *s,struct slab *slab,void **p, -int objects) +alloc_tagging_slab_alloc_hook (struct kmem_cache *s,void *object,gfp_t flags) +{ +if (need_slab_obj_ext ()) +__alloc_tagging_slab_alloc_hook (s, object, flags); +} + +/* Should be called only if mem_alloc_profiling_enabled() */ +static noinline void +__alloc_tagging_slab_free_hook (struct kmem_cache *s,struct slab *slab,void **p, +int objects) {struct slabobj_ext *obj_exts;int i; -if (!mem_alloc_profiling_enabled ()) -return ; -/* slab->obj_exts might not be NULL if it was created for MEMCG accounting. */ if (s->flags & (SLAB_NO_OBJ_EXT |SLAB_NOLEAKTRACE ))return ;
@@ -2119,6 +2124,14 @@ alloc_tagging_slab_free_hook(struct kmem_cache *s, struct slab *slab, void **p, } } +static inline void +alloc_tagging_slab_free_hook (struct kmem_cache *s,struct slab *slab,void **p, +int objects) +{ +if (mem_alloc_profiling_enabled ()) +__alloc_tagging_slab_free_hook (s, slab, p, objects); +} +#else /* CONFIG_MEM_ALLOC_PROFILING */ static inline void
Signature · 1 line
2.48.1.362.g079036d154-goog
Re: [PATCH v2 2/3] alloc_tag: uninline code gated by mem_alloc_profiling_key in slab allocator
Quoted 28 lines · Suren Baghdasaryan
When a sizable code section is protected by a disabled static key, that code gets into the instruction cache even though it's not executed and consumes the cache, increasing cache misses. This can be remedied by moving such code into a separate uninlined function.
On a Pixel6 phone, slab allocation profiling overhead measured withCONFIG_MEM_ALLOC_PROFILING=yand profiling disabled is:baseline modified Big core 3.31% 0.17% Medium core 3.79% 0.57% Little core 6.68% 1.28%This improvement comes at the expense of the configuration when profiling gets enabled, since there is now an additional function call. The overhead from this additional call on Pixel6 is:
Big core 0.66% Middle core 1.23% Little core 2.42%However this is negligible when compared with the overall overhead of the memory allocation profiling when it is enabled.
On x86 this patch does not make noticeable difference because the overhead withmem_alloc_profiling_keydisabled is much lower (under 1%) to start with, so any improvement is less visible and hard to distinguish from the noise. The overhead from additional call when profiling is enabled is also within noise levels.
Quoted 1 line
Signed-off-by Suren Baghdasaryan <[email protected]>
Re: [PATCH v2 2/3] alloc_tag: uninline code gated by mem_alloc_profiling_key in slab allocator
In reply to Suren BaghdasaryanQuoted 28 lines · Suren Baghdasaryan
When a sizable code section is protected by a disabled static key, that code gets into the instruction cache even though it's not executed and consumes the cache, increasing cache misses. This can be remedied by moving such code into a separate uninlined function.
On a Pixel6 phone, slab allocation profiling overhead measured withCONFIG_MEM_ALLOC_PROFILING=yand profiling disabled is:baseline modified Big core 3.31% 0.17% Medium core 3.79% 0.57% Little core 6.68% 1.28%This improvement comes at the expense of the configuration when profiling gets enabled, since there is now an additional function call. The overhead from this additional call on Pixel6 is:
Big core 0.66% Middle core 1.23% Little core 2.42%However this is negligible when compared with the overall overhead of the memory allocation profiling when it is enabled.
On x86 this patch does not make noticeable difference because the overhead withmem_alloc_profiling_keydisabled is much lower (under 1%) to start with, so any improvement is less visible and hard to distinguish from the noise. The overhead from additional call when profiling is enabled is also within noise levels.
Quoted 1 line
Signed-off-by Suren Baghdasaryan <[email protected]>
Suren Baghdasaryan
maintainerPATCH v2 3/3 alloc_tag: uninline code gated by mem_alloc_profiling_key in page allocator
In reply to Suren BaghdasaryanWhen a sizable code section is protected by a disabled static key, that code gets into the instruction cache even though it's not executed and consumes the cache, increasing cache misses. This can be remedied by moving such code into a separate uninlined function.
On a Pixel6 phone, page allocation profiling overhead measured with CONFIG_MEM_ALLOC_PROFILING=y and profiling disabled is:
baseline modified Big core 4.93% 1.53% Medium core 4.39% 1.41% Little core 1.02% 0.36%
This improvement comes at the expense of the configuration when profiling gets enabled, since there is now an additional function call. The overhead from this additional call on Pixel6 is:
Big core 0.24% Middle core 0.63% Little core 1.1%
However this is negligible when compared with the overall overhead of the memory allocation profiling when it is enabled.
On x86 this patch does not make noticeable difference because the overhead with mem_alloc_profiling_key disabled is much lower (under 1%) to start with, so any improvement is less visible and hard to distinguish from the noise. The overhead from additional call when profiling is enabled is also within noise levels.
---
Changes since v1 [1]:
- Removed inline_if_mem_alloc_prof and uninlined the gated code unconditionally, per Steven Rostedt and Vlastimil Babka
- Updated changelog to include overhead when profiling is enabled
[1] https://lore.kernel.org/all/[email protected]/
include/linux/pgalloc_tag.h | 60 +++------------------------- mm/page_alloc.c | 78 +++++++++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+), 55 deletions(-)
include/linux/pgalloc_tag.h +5 -55
@@ -162,47 +162,13 @@ static inline void update_page_tag_ref(union pgtag_ref_handle handle, union code } } -static inline void clear_page_tag_ref (struct page *page) -{ -if (mem_alloc_profiling_enabled ()) { -union pgtag_ref_handle handle; -union codetag_ref ref; - -if (get_page_tag_ref (page, &ref, &handle)) { -set_codetag_empty (&ref); -update_page_tag_ref (handle, &ref); -put_page_tag_ref (handle); - } - } -} - -static inline void pgalloc_tag_add (struct page *page,struct task_struct *task, -unsigned int nr) -{ -if (mem_alloc_profiling_enabled ()) { -union pgtag_ref_handle handle; -union codetag_ref ref; - -if (get_page_tag_ref (page, &ref, &handle)) { -alloc_tag_add (&ref, task->alloc_tag,PAGE_SIZE * nr); -update_page_tag_ref (handle, &ref); -put_page_tag_ref (handle); - } - } -} +/* Should be called only if mem_alloc_profiling_enabled() */ +void __clear_page_tag_ref (struct page *page); -static inline void pgalloc_tag_sub (struct page *page,unsigned int nr) +static inline void clear_page_tag_ref (struct page *page) { -if (mem_alloc_profiling_enabled ()) { -union pgtag_ref_handle handle; -union codetag_ref ref; - -if (get_page_tag_ref (page, &ref, &handle)) { -alloc_tag_sub (&ref,PAGE_SIZE * nr); -update_page_tag_ref (handle, &ref); -put_page_tag_ref (handle); - } - } +if (mem_alloc_profiling_enabled ()) +__clear_page_tag_ref (page); }/* Should be called only if mem_alloc_profiling_enabled() */
@@ -222,18 +188,6 @@ static inline struct alloc_tag *__pgalloc_tag_get(struct page *page)return tag; } -static inline void pgalloc_tag_sub_pages (struct page *page,unsigned int nr) -{ -struct alloc_tag *tag; - -if (!mem_alloc_profiling_enabled ()) -return ; - - tag =__pgalloc_tag_get (page); -if (tag) -this_cpu_sub (tag->counters->bytes,PAGE_SIZE * nr); -} -void pgalloc_tag_split (struct folio *folio,int old_order,int new_order);void pgalloc_tag_swap (struct folio *new,struct folio *old);
@@ -242,10 +196,6 @@ void __init alloc_tag_sec_init(void);#else /* CONFIG_MEM_ALLOC_PROFILING */ static inline void clear_page_tag_ref (struct page *page) {} -static inline void pgalloc_tag_add (struct page *page,struct task_struct *task, -unsigned int nr) {} -static inline void pgalloc_tag_sub (struct page *page,unsigned int nr) {} -static inline void pgalloc_tag_sub_pages (struct page *page,unsigned int nr) {}static inline void alloc_tag_sec_init (void ) {}static inline void pgalloc_tag_split (struct folio *folio,int old_order,int new_order) {}static inline void pgalloc_tag_swap (struct folio *new,struct folio *old) {}
mm/page_alloc.c +78 -0
84 lines not on this page · raw message
Signature · 1 line
2.48.1.362.g079036d154-goog
Re: [PATCH v2 3/3] alloc_tag: uninline code gated by mem_alloc_profiling_key in page allocator
Quoted 28 lines · Suren Baghdasaryan
When a sizable code section is protected by a disabled static key, that code gets into the instruction cache even though it's not executed and consumes the cache, increasing cache misses. This can be remedied by moving such code into a separate uninlined function.
On a Pixel6 phone, page allocation profiling overhead measured withCONFIG_MEM_ALLOC_PROFILING=yand profiling disabled is:baseline modified Big core 4.93% 1.53% Medium core 4.39% 1.41% Little core 1.02% 0.36%This improvement comes at the expense of the configuration when profiling gets enabled, since there is now an additional function call. The overhead from this additional call on Pixel6 is:
Big core 0.24% Middle core 0.63% Little core 1.1%However this is negligible when compared with the overall overhead of the memory allocation profiling when it is enabled.
On x86 this patch does not make noticeable difference because the overhead withmem_alloc_profiling_keydisabled is much lower (under 1%) to start with, so any improvement is less visible and hard to distinguish from the noise. The overhead from additional call when profiling is enabled is also within noise levels.
Quoted 1 line
Signed-off-by Suren Baghdasaryan <[email protected]>
One question: Is there any plan to enable MEM_ALLOC_PROFILING by default in future?
Suren Baghdasaryan
maintainerRe: [PATCH v2 3/3] alloc_tag: uninline code gated by mem_alloc_profiling_key in page allocator
Quoted 30 lines · Shakeel Butt
Quoted 28 lines · Suren Baghdasaryan
When a sizable code section is protected by a disabled static key, that code gets into the instruction cache even though it's not executed and consumes the cache, increasing cache misses. This can be remedied by moving such code into a separate uninlined function.
On a Pixel6 phone, page allocation profiling overhead measured withCONFIG_MEM_ALLOC_PROFILING=yand profiling disabled is:baseline modified Big core 4.93% 1.53% Medium core 4.39% 1.41% Little core 1.02% 0.36%This improvement comes at the expense of the configuration when profiling gets enabled, since there is now an additional function call. The overhead from this additional call on Pixel6 is:
Big core 0.24% Middle core 0.63% Little core 1.1%However this is negligible when compared with the overall overhead of the memory allocation profiling when it is enabled.
On x86 this patch does not make noticeable difference because the overhead withmem_alloc_profiling_keydisabled is much lower (under 1%) to start with, so any improvement is less visible and hard to distinguish from the noise. The overhead from additional call when profiling is enabled is also within noise levels.
Quoted 6 lines
Quoted 1 line
Signed-off-by Suren Baghdasaryan <[email protected]>Reviewed-by Shakeel Butt <[email protected]>One question: Is there any plan to enable
MEM_ALLOC_PROFILINGby default in future?
It's left up to each distribution. In Android Common Kernel we are enabling it with CONFIG_MEM_ALLOC_PROFILING_ENABLED_BY_DEFAULT=n and allow vendors to enable it using kernel command line parameters.
Quoted 1 line
Quoted 5 lines · Suren Baghdasaryan
Refactor code to avoid extra
mem_alloc_profiling_enabled()checks insidepgalloc_tag_get()function which is often called after that check was already done.Signed-off-by Suren Baghdasaryan <[email protected]>