mm/damon: Add CMA minotor support
Subsystems (2)
cover mm/damon: Add CMA minotor support
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
These patches is only preliminarily for monitoring function, About the reclaim, it need to do some fixes base on "reclaim.c" and more tests, I will implement it in the next patch series.
Xin Hao (3):
mm/damon: rename damon_evenly_split_region() mm/damon/paddr: Move "paddr" relative func to ops-common.c file mm/damon/sysfs: Add CMA memory monitoring
include/linux/damon.h | 1 + mm/damon/Makefile | 2 +- mm/damon/ops-common.c | 286 ++++++++++++++++++++++++++++++++++++++++++ mm/damon/ops-common.h | 18 +++ mm/damon/paddr-cma.c | 104 +++++++++++++++ mm/damon/paddr.c | 246 ------------------------------------ mm/damon/sysfs.c | 1 + mm/damon/vaddr-test.h | 6 +- mm/damon/vaddr.c | 41 +----- 9 files changed, 415 insertions(+), 290 deletions(-) create mode 100644 mm/damon/paddr-cma.c
--
2.27.0
RFC PATCH 1/3 mm/damon: rename damon_evenly_split_region()
This patch rename damon_va_evenly_split_region() to damon_evenly_split_region() is aimed to call it in the physical address space.
So there fix it, and move it to "ops-common.c" file.
--- mm/damon/ops-common.c | 39 +++++++++++++++++++++++++++++++++++++++ mm/damon/ops-common.h | 3 +++ mm/damon/vaddr-test.h | 6 +++--- mm/damon/vaddr.c | 41 +---------------------------------------- 4 files changed, 46 insertions(+), 43 deletions(-)
mm/damon/ops-common.c +39 -0
@@ -131,3 +131,42 @@ int damon_pageout_score(struct damon_ctx *c, struct damon_region *r,/* Return coldness of the region */ return DAMOS_MAX_SCORE - hotness; } + +/* +* Size-evenly split a region into 'nr_pieces' small regions +* +* Returns 0 on success, or negative error code otherwise. +*/ +int damon_evenly_split_region (struct damon_target *t, +struct damon_region *r,unsigned int nr_pieces) +{ +unsigned long sz_orig, sz_piece, orig_end; +struct damon_region *n =NULL , *next; +unsigned long start; + +if (!r || !nr_pieces) +return -EINVAL ; + + orig_end = r->ar.end; + sz_orig = r->ar.end - r->ar.start; + sz_piece =ALIGN_DOWN (sz_orig / nr_pieces,DAMON_MIN_REGION ); + +if (!sz_piece) +return -EINVAL ; + + r->ar.end = r->ar.start + sz_piece; + next =damon_next_region (r); +for (start = r->ar.end; start + sz_piece <= orig_end; + start += sz_piece) { + n =damon_new_region (start, start + sz_piece); +if (!n) +return -ENOMEM ; +damon_insert_region (n, r, next, t); + r = n; + } +/* complement last region for possible rounding error */ +if (n) + n->ar.end = orig_end; + +return 0 ; +}
mm/damon/ops-common.h +3 -0
@@ -14,3 +14,6 @@ void damon_pmdp_mkold(pmd_t *pmd, struct mm_struct *mm, unsigned long addr);int damon_pageout_score (struct damon_ctx *c,struct damon_region *r,struct damos *s); + +int damon_evenly_split_region (struct damon_target *t, +struct damon_region *r,unsigned int nr_pieces);
mm/damon/vaddr-test.h +3 -3
@@ -256,7 +256,7 @@ static void damon_test_split_evenly_fail(struct kunit *test,damon_add_region (r, t);KUNIT_EXPECT_EQ (test, -damon_va_evenly_split_region (t, r, nr_pieces), -EINVAL ); +damon_evenly_split_region (t, r, nr_pieces), -EINVAL );KUNIT_EXPECT_EQ (test,damon_nr_regions (t),1u );damon_for_each_region (r, t) {
@@ -277,7 +277,7 @@ static void damon_test_split_evenly_succ(struct kunit *test,damon_add_region (r, t);KUNIT_EXPECT_EQ (test, -damon_va_evenly_split_region (t, r, nr_pieces),0 ); +damon_evenly_split_region (t, r, nr_pieces),0 );KUNIT_EXPECT_EQ (test,damon_nr_regions (t), nr_pieces);damon_for_each_region (r, t) {
@@ -294,7 +294,7 @@ static void damon_test_split_evenly_succ(struct kunit *test,static void damon_test_split_evenly (struct kunit *test) { -KUNIT_EXPECT_EQ (test,damon_va_evenly_split_region (NULL ,NULL ,5 ), +KUNIT_EXPECT_EQ (test,damon_evenly_split_region (NULL ,NULL ,5 ), -EINVAL );damon_test_split_evenly_fail (test,0 ,100 ,0 );
mm/damon/vaddr.c +1 -40
53 lines not on this page · raw message
Signature · 1 line
2.27.0
RFC PATCH 3/3 mm/damon/sysfs: Add CMA memory monitoring
In reply to Xin HaoUsers can do the CMA memory monitoring by writing a special keyword 'cma' to the 'operations' sysfs file. Then, DAMON will check the special keyword and configure the monitoring context to run with the CMA reserved physical address space.
Unlike other physical memorys monitoring, the monitoring target region will be automatically set.
--- include/linux/damon.h | 1 + mm/damon/Makefile | 2 +- mm/damon/paddr-cma.c | 104 ++++++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs.c | 1 + 4 files changed, 107 insertions(+), 1 deletion(-) create mode 100644 mm/damon/paddr-cma.c
include/linux/damon.h +1 -0
@@ -266,6 +266,7 @@ struct damos {enum damon_ops_id {DAMON_OPS_VADDR ,DAMON_OPS_PADDR , +DAMON_OPS_CMA ,NR_DAMON_OPS , };
mm/damon/Makefile +1 -1
@@ -2,7 +2,7 @@ obj-y := core.o obj-$(CONFIG_DAMON_VADDR) += ops-common.o vaddr.o -obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o +obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o paddr-cma.o obj-$(CONFIG_DAMON_SYSFS) += sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o obj-$(CONFIG_DAMON_RECLAIM) += reclaim.o
mm/damon/paddr-cma.c new file +104 -0
104 lines not on this page · raw message
mm/damon/sysfs.c +1 -0
@@ -1761,6 +1761,7 @@ static struct kobj_type damon_sysfs_attrs_ktype = {static const char *const damon_sysfs_ops_strs[] = {"vaddr" ,"paddr" , +"cma" , };struct damon_sysfs_context {
Signature · 1 line
2.27.0
RFC PATCH 2/3 mm/damon/paddr: Move "paddr" relative func to ops-common.c file
In reply to Xin HaoIn the next patch, I will introduce the CMA monitoring support, because CMA is also based on physical addresses, so there are many functions can be shared with "paddr".
--- mm/damon/ops-common.c | 247 ++++++++++++++++++++++++++++++++++++++++++ mm/damon/ops-common.h | 15 +++ mm/damon/paddr.c | 246 ----------------------------------------- 3 files changed, 262 insertions(+), 246 deletions(-)
mm/damon/ops-common.c +247 -0
@@ -9,8 +9,11 @@#include <linux/page_idle.h> #include <linux/pagemap.h> #include <linux/rmap.h> +#include <linux/mmu_notifier.h> +#include <linux/swap.h> #include "ops-common.h" +#include "../internal.h" /* * Get an online page for a pfn if it's in the LRU list. Otherwise, returns
@@ -170,3 +173,247 @@ int damon_evenly_split_region(struct damon_target *t,return 0 ; } + +#ifdef CONFIG_DAMON_PADDR + +static bool __damon_pa_mkold (struct page *page,struct vm_area_struct *vma, +unsigned long addr,void *arg) +{ +struct page_vma_mapped_walk pvmw = { + .page = page, + .vma = vma, + .address = addr, + }; + +while (page_vma_mapped_walk (&pvmw)) { + addr = pvmw.address; +if (pvmw.pte) +damon_ptep_mkold (pvmw.pte, vma->vm_mm, addr); +else +damon_pmdp_mkold (pvmw.pmd, vma->vm_mm, addr); + } +return true; +} + +void damon_pa_mkold (unsigned long paddr) +{ +struct page *page =damon_get_page (PHYS_PFN (paddr)); +struct rmap_walk_control rwc = { + .rmap_one = __damon_pa_mkold, + .anon_lock = page_lock_anon_vma_read, + }; +bool need_lock; + +if (!page) +return ; + +if (!page_mapped (page) || !page_rmapping (page)) { +set_page_idle (page); + goto out; + } + + need_lock = !PageAnon (page) ||PageKsm (page); +if (need_lock && !trylock_page (page)) + goto out; + +rmap_walk (page, &rwc); + +if (need_lock) +unlock_page (page); + +out: +put_page (page); +} + +static void __damon_pa_prepare_access_check (struct damon_ctx *ctx, +struct damon_region *r) +{ + r->sampling_addr =damon_rand (r->ar.start, r->ar.end); + +damon_pa_mkold (r->sampling_addr); +} + +void damon_pa_prepare_access_checks (struct damon_ctx *ctx) +{ +struct damon_target *t; +struct damon_region *r; + +damon_for_each_target (t, ctx) { +damon_for_each_region (r, t) +__damon_pa_prepare_access_check (ctx, r); + } +} + +struct damon_pa_access_chk_result { +unsigned long page_sz; +bool accessed; +}; + +static bool __damon_pa_young (struct page *page,struct vm_area_struct *vma, +unsigned long addr,void *arg) +{ +struct damon_pa_access_chk_result *result = arg; +struct page_vma_mapped_walk pvmw = { + .page = page, + .vma = vma, + .address = addr, + }; + + result->accessed = false; + result->page_sz =PAGE_SIZE ; +while (page_vma_mapped_walk (&pvmw)) { + addr = pvmw.address; +if (pvmw.pte) { + result->accessed =pte_young (*pvmw.pte) || + !page_is_idle (page) || +mmu_notifier_test_young (vma->vm_mm, addr); + }else { +#ifdef CONFIG_TRANSPARENT_HUGEPAGE + result->accessed =pmd_young (*pvmw.pmd) || + !page_is_idle (page) || +mmu_notifier_test_young (vma->vm_mm, addr); + result->page_sz = ((1UL ) <<HPAGE_PMD_SHIFT ); +#else +WARN_ON_ONCE (1 ); +#endif /* CONFIG_TRANSPARENT_HUGEPAGE */ + } +if (result->accessed) { +page_vma_mapped_walk_done (&pvmw); +break ; + } + } + +/* If accessed, stop walking */ +return !result->accessed; +} + +bool damon_pa_young (unsigned long paddr,unsigned long *page_sz) +{ +struct page *page =damon_get_page (PHYS_PFN (paddr)); +struct damon_pa_access_chk_result result = { + .page_sz =PAGE_SIZE , + .accessed = false, + }; +struct rmap_walk_control rwc = { + .arg = &result, + .rmap_one = __damon_pa_young, + .anon_lock = page_lock_anon_vma_read, + }; +bool need_lock; + +if (!page) +return false; + +if (!page_mapped (page) || !page_rmapping (page)) { +if (page_is_idle (page)) + result.accessed = false; +else + result.accessed = true; +put_page (page); + goto out; + } + + need_lock = !PageAnon (page) ||PageKsm (page); +if (need_lock && !trylock_page (page)) { +put_page (page); +return NULL ; + } + +rmap_walk (page, &rwc); + +if (need_lock) +unlock_page (page); +put_page (page); + +out: + *page_sz = result.page_sz; +return result.accessed; +} + +static void __damon_pa_check_access (struct damon_ctx *ctx, +struct damon_region *r) +{ +static unsigned long last_addr; +static unsigned long last_page_sz =PAGE_SIZE ; +static bool last_accessed; + +/* If the region is in the last checked page, reuse the result */ +if (ALIGN_DOWN (last_addr, last_page_sz) == +ALIGN_DOWN (r->sampling_addr, last_page_sz)) { +if (last_accessed) + r->nr_accesses++; +return ; + } + + last_accessed =damon_pa_young (r->sampling_addr, &last_page_sz); +if (last_accessed) + r->nr_accesses++; + + last_addr = r->sampling_addr; +} + +unsigned int damon_pa_check_accesses (struct damon_ctx *ctx) +{ +struct damon_target *t; +struct damon_region *r; +unsigned int max_nr_accesses =0 ; + +damon_for_each_target (t, ctx) { +damon_for_each_region (r, t) { +__damon_pa_check_access (ctx, r); + max_nr_accesses =max (r->nr_accesses, max_nr_accesses); + } + } + +return max_nr_accesses; +} + +unsigned long damon_pa_apply_scheme (struct damon_ctx *ctx, +struct damon_target *t,struct damon_region *r, +struct damos *scheme) +{ +unsigned long addr, applied; +LIST_HEAD (page_list); + +if (scheme->action !=DAMOS_PAGEOUT ) +return 0 ; + +for (addr = r->ar.start; addr < r->ar.end; addr +=PAGE_SIZE ) { +struct page *page =damon_get_page (PHYS_PFN (addr)); + +if (!page) +continue ; + +ClearPageReferenced (page); +test_and_clear_page_young (page); +if (isolate_lru_page (page)) { +put_page (page); +continue ; + } +if (PageUnevictable (page)) { +putback_lru_page (page); + }else { +list_add (&page->lru, &page_list); +put_page (page); + } + } + applied =reclaim_pages (&page_list); +cond_resched (); +return applied *PAGE_SIZE ; +} + +int damon_pa_scheme_score (struct damon_ctx *context, +struct damon_target *t,struct damon_region *r, +struct damos *scheme) +{ +switch (scheme->action) { +case DAMOS_PAGEOUT : +return damon_pageout_score (context, r, scheme); +default : +break ; + } + +return DAMOS_MAX_SCORE ; +} + +#endif /* CONFIG_DAMON_PADDR */
mm/damon/ops-common.h +15 -0
@@ -17,3 +17,18 @@ int damon_pageout_score(struct damon_ctx *c, struct damon_region *r,int damon_evenly_split_region (struct damon_target *t,struct damon_region *r,unsigned int nr_pieces); + +#ifdef CONFIG_DAMON_PADDR + +void damon_pa_mkold (unsigned long paddr); +void damon_pa_prepare_access_checks (struct damon_ctx *ctx); +bool damon_pa_young (unsigned long paddr,unsigned long *page_sz); +unsigned int damon_pa_check_accesses (struct damon_ctx *ctx); +unsigned long damon_pa_apply_scheme (struct damon_ctx *ctx, +struct damon_target *t,struct damon_region *r, +struct damos *scheme); +int damon_pa_scheme_score (struct damon_ctx *context, +struct damon_target *t,struct damon_region *r, +struct damos *scheme); + +#endif
mm/damon/paddr.c +0 -246
255 lines not on this page · raw message
Signature · 1 line
2.27.0
On 15.03.22 17:37, Xin Hao wrote:
s/minotor/monitor/
Quoted 3 lines
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
I'm sorry, but it's hard to figure out what the target use case should be. Who will release CMA memory and how? Who will monitor that? What are the "some memory tight scenarios"? What's the overall design goal?
Signature · 3 lines
Thanks, David / dhildenb
Hi David,
Quoted 3 lines · David Hildenbrand
On 15.03.22 17:37, Xin Hao wrote:
s/minotor/monitor/
Thanks, i will fix it.
Quoted 7 lines
Quoted 4 lines
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
I'm sorry, but it's hard to figure out what the target use case should be. Who will release CMA memory and how? Who will monitor that? What are the "some memory tight scenarios"? What's the overall design goal?
I may not be describing exactly what i mean,My intention is to find out how much of the reserved CMA space is actually used and which is unused,
For those that are not used, I understand that they can be released by cma_release(). Of course, This is just a little personal thought that I think is helpful for saving memory.
Quoted 1 line
Signature · 2 lines
Best Regards! Xin Hao
Quoted 11 lines · Xin Hao
Hi David,
Quoted 3 lines · David Hildenbrand
On 15.03.22 17:37, Xin Hao wrote:
s/minotor/monitor/
Thanks, i will fix it.
Quoted 4 lines
Quoted 4 lines
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
Quoted 8 lines
Quoted 3 lines
I'm sorry, but it's hard to figure out what the target use case should be. Who will release CMA memory and how? Who will monitor that? What are the "some memory tight scenarios"? What's the overall design goal?
I may not be describing exactly what i mean,My intention is to find out how much of the reserved CMA space is actually used and which is unused, For those that are not used, I understand that they can be released by
cma_release(). Of course, This is just a little personal thought that I think is helpful for saving memory.
Hm, not quite. We can place movable allocations on cma areas, to be migrated away once required for allocations via CMA. So just looking at the pages allocated within a CMA area doesn't really tell you what's actually going on.
Signature · 3 lines
Thanks, David / dhildenb
Quoted 19 lines · David Hildenbrand
Quoted 10 lines · Xin Hao
Hi David,
Quoted 3 lines · David Hildenbrand
On 15.03.22 17:37, Xin Hao wrote:
s/minotor/monitor/
Thanks, i will fix it.
Quoted 3 lines
Quoted 3 lines
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
Quoted 8 lines
Quoted 3 lines
I'm sorry, but it's hard to figure out what the target use case should be. Who will release CMA memory and how? Who will monitor that? What are the "some memory tight scenarios"? What's the overall design goal?
I may not be describing exactly what i mean,My intention is to find out how much of the reserved CMA space is actually used and which is unused, For those that are not used, I understand that they can be released by
cma_release(). Of course, This is just a little personal thought that I think is helpful for saving memory.
Quoted 4 lines
Hm, not quite. We can place movable allocations on cma areas, to be migrated away once required for allocations via CMA. So just looking at the pages allocated within a CMA area doesn't really tell you what's actually going on.
I don't think so, the damon not looking at the pages allocate, It is constantly monitoring who is using CMA area pages through tracking page access bit
in the kernel via the kdamond.x thread, So through damon, it can tell us about the hot and cold distribution of CMA memory.
--cc SeongJae Park <[email protected]>
More about damon, you can refer to this link:https://sjp38.github.io/post/damon/ <https://sjp38.github.io/post/damon/>
Quoted 1 line
Signature · 2 lines
Best Regards! Xin Hao
Quoted 26 lines · On 18.03.22 06:13, [email protected] wrote:
Quoted 19 lines · David Hildenbrand
Quoted 10 lines · Xin Hao
Hi David,
Quoted 3 lines · David Hildenbrand
On 15.03.22 17:37, Xin Hao wrote:
s/minotor/monitor/
Thanks, i will fix it.
Quoted 3 lines
Quoted 3 lines
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
Quoted 8 lines
Quoted 3 lines
I'm sorry, but it's hard to figure out what the target use case should be. Who will release CMA memory and how? Who will monitor that? What are the "some memory tight scenarios"? What's the overall design goal?
I may not be describing exactly what i mean,My intention is to find out how much of the reserved CMA space is actually used and which is unused, For those that are not used, I understand that they can be released by
cma_release(). Of course, This is just a little personal thought that I think is helpful for saving memory.Quoted 4 lines
Hm, not quite. We can place movable allocations on cma areas, to be migrated away once required for allocations via CMA. So just looking at the pages allocated within a CMA area doesn't really tell you what's actually going on.
Quoted 6 lines
I don't think so, the damon not looking at the pages allocate, It is constantly monitoring who is using CMA area pages through tracking page access bit
in the kernel via the kdamond.x thread, So through damon, it can tell us about the hot and cold distribution of CMA memory.
I'm not sure I follow. With random movable pages being placed on the CMA area, the mentioned use case of "cma_release()" to release pages doesn't make sense to me.
I assume I'm missing the big picture -- and that should be properly documented in the patch description. We don't add stuff just because it could be used somehow, there should be a clear motivation how it can actually be used.
Signature · 3 lines
Thanks, David / dhildenb
[email protected]
maintainerQuoted 34 lines · On Fri, 18 Mar 2022 09:29:20 +0100 David Hildenbrand <[email protected]> wrote:
Quoted 26 lines · On 18.03.22 06:13, [email protected] wrote:
Quoted 19 lines · David Hildenbrand
Quoted 10 lines · Xin Hao
Hi David,
Quoted 3 lines · David Hildenbrand
On 15.03.22 17:37, Xin Hao wrote:
s/minotor/monitor/
Thanks, i will fix it.
Quoted 3 lines
Quoted 3 lines
The purpose of these patches is to add CMA memory monitoring function. In some memory tight scenarios, it will be a good choice to release more memory by monitoring the CMA memory.
Quoted 8 lines
Quoted 3 lines
I'm sorry, but it's hard to figure out what the target use case should be. Who will release CMA memory and how? Who will monitor that? What are the "some memory tight scenarios"? What's the overall design goal?
I may not be describing exactly what i mean,My intention is to find out how much of the reserved CMA space is actually used and which is unused, For those that are not used, I understand that they can be released by
cma_release(). Of course, This is just a little personal thought that I think is helpful for saving memory.Quoted 4 lines
Hm, not quite. We can place movable allocations on cma areas, to be migrated away once required for allocations via CMA. So just looking at the pages allocated within a CMA area doesn't really tell you what's actually going on.
Quoted 6 lines
I don't think so, the damon not looking at the pages allocate, It is constantly monitoring who is using CMA area pages through tracking page access bit
in the kernel via the kdamond.x thread, So through damon, it can tell us about the hot and cold distribution of CMA memory.
Quoted 8 lines
I'm not sure I follow. With random movable pages being placed on the CMA area, the mentioned use case of "
cma_release()" to release pages doesn't make sense to me.I assume I'm missing the big picture -- and that should be properly documented in the patch description. We don't add stuff just because it could be used somehow, there should be a clear motivation how it can actually be used.
Same opinion from my side. The purpose and usage of this patch is unclear to me. Could you please clarify more, Xin?
Thanks,
SJ
Quoted 5 lines
Signature · 4 lines
-- Thanks, David / dhildenb