efficiently expose damos action tried regions information
Subsystems (4)
SeongJae Park
maintainercover efficiently expose damos action tried regions information
DAMON users can retrieve the monitoring results via 'after_aggregation' callbacks if the user is using the kernel API, or 'damon_aggregated' tracepoint if the user is in the user space. Those are useful if full monitoring results are necessary. However, if the user has interest in only some regions having specific access pattern, the interfaces could be inefficient. For example, some DAMOS users might want to know exactly what regions were identified as fulfilling the access pattern of the scheme, for a debugging or a tuning.
This patchset implements DAMON kernel API callbacks and sysfs directory for efficient exposure of the information. The new callback will be called for each region before specific DAMOS action is gonna tried to be applied. The sysfs directory will be called 'tried_regions' and placed under each scheme sysfs directory. User can write a special keyworkd, 'update_schemes_regions' to the 'state' file of a kdamond sysfs directory. Then, DAMON sysfs interface will fill the directory with the information of regions that corresponding scheme action was tried to be applied for one aggregation interval.
Patches Sequence
----------------
First five patches (1-5) clean up and refactor code that following patch will touch, and the following one (patch 6) implements the DAMON callback for DAMON kernel API users.
Following six patches (7-12) clean up and refactor the sysfs interface before the new sysfs directory introduction. Following two patches (13 and 14) implement the sysfs directories, and successing two patches (15 and 16) implement the special keyword for 'state' to fill and clean up the directories.
Finally, two more patches (17 and 18) for the documentation of the usage and ABI follow.
Assembled Tree
--------------
This patchset is based on the latest mm-unstable tree[1]. Assembled tree is also available at the damon/next tree[2].
[1] https://git.kernel.org/akpm/mm/h/mm-unstable
[2] https://git.kernel.org/sj/h/damon/next
SeongJae Park (18):
mm/damon/modules: deduplicate init steps for DAMON context setup mm/damon/core: split out DAMOS-charged region skip logic into a new
function
mm/damon/core: split damos application logic into a new function mm/damon/core: split out scheme stat update logic into a new function mm/damon/core: split out scheme quota adjustment logic into a new
function
mm/damon/core: add a DAMON callback for scheme target regions check mm/damon/sysfs: Use damon_addr_range for regions' start and end values mm/damon/sysfs: remove parameters of damon_sysfs_region_alloc() mm/damon/sysfs: move sysfs_lock to common module mm/damon/sysfs: move unsigned long range directory to common module mm/damon/sysfs: split out kdamond-independent schemes stats update
logic into a new function
mm/damon/sysfs: move schemes directory implementation to separate
module
mm/damon/sysfs-schemes: implement schemes/tried_regions directory mm/damon/sysfs-schemes: implement scheme region directory mm/damon/sysfs: implement DAMOS-tried regions update command mm/damon/sysfs-schemes: implement DAMOS tried regions clear command Docs/admin-guide/mm/damon/usage: document schemes/<s>/tried_regions
directory
Docs/ABI/damon: document 'schemes/<s>/tried_regions' directory
.../ABI/testing/sysfs-kernel-mm-damon | 32 + Documentation/admin-guide/mm/damon/usage.rst | 44 +- include/linux/damon.h | 5 + mm/damon/Makefile | 6 +- mm/damon/core.c | 259 ++-- mm/damon/lru_sort.c | 17 +- mm/damon/modules-common.c | 42 + mm/damon/modules-common.h | 3 + mm/damon/reclaim.c | 17 +- mm/damon/sysfs-common.c | 107 ++ mm/damon/sysfs-common.h | 56 + mm/damon/sysfs-schemes.c | 1281 +++++++++++++++++ mm/damon/sysfs.c | 1224 ++-------------- 13 files changed, 1813 insertions(+), 1280 deletions(-) create mode 100644 mm/damon/modules-common.c create mode 100644 mm/damon/sysfs-common.c create mode 100644 mm/damon/sysfs-common.h create mode 100644 mm/damon/sysfs-schemes.c
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 1/18 mm/damon/modules: deduplicate init steps for DAMON context setup
DAMON_RECLAIM and DAMON_LRU_SORT has duplicated code for DAMON context and target initializations. Deduplicate the part by implementing a function for the initialization in 'modules-common.c' and using it.
--- mm/damon/Makefile | 4 ++-- mm/damon/lru_sort.c | 17 +++------------- mm/damon/modules-common.c | 42 +++++++++++++++++++++++++++++++++++++++ mm/damon/modules-common.h | 3 +++ mm/damon/reclaim.c | 17 +++------------- 5 files changed, 53 insertions(+), 30 deletions(-) create mode 100644 mm/damon/modules-common.c
mm/damon/Makefile +2 -2
@@ -5,5 +5,5 @@ obj-$(CONFIG_DAMON_VADDR) += ops-common.o vaddr.o obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o obj-$(CONFIG_DAMON_SYSFS) += sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o -obj-$(CONFIG_DAMON_RECLAIM) += reclaim.o -obj-$(CONFIG_DAMON_LRU_SORT) += lru_sort.o +obj-$(CONFIG_DAMON_RECLAIM) += modules-common.o reclaim.o +obj-$(CONFIG_DAMON_LRU_SORT) += modules-common.o lru_sort.o
mm/damon/lru_sort.c +3 -14
@@ -314,25 +314,14 @@ static int damon_lru_sort_after_wmarks_check(struct damon_ctx *c)static int __init damon_lru_sort_init (void ) { - ctx =damon_new_ctx (); -if (!ctx) -return -ENOMEM ; +int err =damon_modules_new_paddr_ctx_target (&ctx, &target); -if (damon_select_ops (ctx,DAMON_OPS_PADDR )) { -damon_destroy_ctx (ctx); -return -EINVAL ; - } +if (err) +return err; ctx->callback.after_wmarks_check = damon_lru_sort_after_wmarks_check; ctx->callback.after_aggregation = damon_lru_sort_after_aggregation; - target =damon_new_target (); -if (!target) { -damon_destroy_ctx (ctx); -return -ENOMEM ; - } -damon_add_target (ctx, target); -schedule_delayed_work (&damon_lru_sort_timer,0 ); damon_lru_sort_initialized = true;
mm/damon/modules-common.c new file +42 -0
42 lines not on this page · raw message
mm/damon/modules-common.h +3 -0
@@ -44,3 +44,6 @@ 0400); \ module_param_named(nr_##qt_exceed_name, stat.qt_exceeds, ulong, \ 0400); + +int damon_modules_new_paddr_ctx_target (struct damon_ctx **ctxp, +struct damon_target **targetp);
mm/damon/reclaim.c +3 -14
@@ -256,25 +256,14 @@ static int damon_reclaim_after_wmarks_check(struct damon_ctx *c)static int __init damon_reclaim_init (void ) { - ctx =damon_new_ctx (); -if (!ctx) -return -ENOMEM ; +int err =damon_modules_new_paddr_ctx_target (&ctx, &target); -if (damon_select_ops (ctx,DAMON_OPS_PADDR )) { -damon_destroy_ctx (ctx); -return -EINVAL ; - } +if (err) +return err; ctx->callback.after_wmarks_check = damon_reclaim_after_wmarks_check; ctx->callback.after_aggregation = damon_reclaim_after_aggregation; - target =damon_new_target (); -if (!target) { -damon_destroy_ctx (ctx); -return -ENOMEM ; - } -damon_add_target (ctx, target); -schedule_delayed_work (&damon_reclaim_timer,0 ); damon_reclaim_initialized = true;
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 2/18 mm/damon/core: split out DAMOS-charged region skip logic into a new function
In reply to SeongJae ParkThe DAMOS action applying function, 'damon_do_apply_schemes()', is quite long and not easy to read. Split out the already quota-charged region skip code into a new function with some comments for better readability.
--- mm/damon/core.c | 89 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 58 insertions(+), 31 deletions(-)
mm/damon/core.c +58 -31
@@ -694,6 +694,60 @@ static bool damos_valid_target(struct damon_ctx *c, struct damon_target *t,return c->ops.get_scheme_score (c, t, r, s) >= s->quota.min_score; } +/* +* damos_skip_charged_region() - Check if the given region or starting part of +* it is already charged for the DAMOS quota. +* @t: The target of the region. +* @rp: The pointer to the region. +* @s: The scheme to be applied. +* +* If the scheme has applied to only a part of the memory regions fulfilling +* the access pattern due to the charge limit, we start from the memory region +* of the access pattern after already charged one. For this, this function +* checks if current region should be skipped or not. If only the starting +* part of the region is previously charged, this function splits the region +* into two, so that the second one can start DAMOS, and saves the second +* region in *rp. +*/ +static bool damos_skip_charged_region (struct damon_target *t, +struct damon_region **rp,struct damos *s) +{ +struct damon_region *r = *rp; +struct damos_quota *quota = &s->quota; +unsigned long sz_to_skip; + +/* Skip previously charged regions */ +if (quota->charge_target_from) { +if (t != quota->charge_target_from) +return true; +if (r ==damon_last_region (t)) { + quota->charge_target_from =NULL ; + quota->charge_addr_from =0 ; +return true; + } +if (quota->charge_addr_from && + r->ar.end <= quota->charge_addr_from) +return true; + +if (quota->charge_addr_from && r->ar.start < + quota->charge_addr_from) { + sz_to_skip =ALIGN_DOWN (quota->charge_addr_from - + r->ar.start,DAMON_MIN_REGION ); +if (!sz_to_skip) { +if (damon_sz_region (r) <=DAMON_MIN_REGION ) +return true; + sz_to_skip =DAMON_MIN_REGION ; + } +damon_split_region_at (t, r, sz_to_skip); + r =damon_next_region (r); + *rp = r; + } + quota->charge_target_from =NULL ; + quota->charge_addr_from =0 ; + } +return false; +} +static void damon_do_apply_schemes (struct damon_ctx *c,struct damon_target *t,struct damon_region *r)
@@ -702,7 +756,7 @@ static void damon_do_apply_schemes(struct damon_ctx *c,damon_for_each_scheme (s, c) {struct damos_quota *quota = &s->quota; -unsigned long sz =damon_sz_region (r); +unsigned long sz;struct timespec64 begin, end;unsigned long sz_applied =0 ;
@@ -713,41 +767,14 @@ static void damon_do_apply_schemes(struct damon_ctx *c,if (quota->esz && quota->charged_sz >= quota->esz)continue ; -/* Skip previously charged regions */ -if (quota->charge_target_from) { -if (t != quota->charge_target_from) -continue ; -if (r ==damon_last_region (t)) { - quota->charge_target_from =NULL ; - quota->charge_addr_from =0 ; -continue ; - } -if (quota->charge_addr_from && - r->ar.end <= quota->charge_addr_from) -continue ; - -if (quota->charge_addr_from && r->ar.start < - quota->charge_addr_from) { - sz =ALIGN_DOWN (quota->charge_addr_from - - r->ar.start,DAMON_MIN_REGION ); -if (!sz) { -if (damon_sz_region (r) <= -DAMON_MIN_REGION ) -continue ; - sz =DAMON_MIN_REGION ; - } -damon_split_region_at (t, r, sz); - r =damon_next_region (r); - sz =damon_sz_region (r); - } - quota->charge_target_from =NULL ; - quota->charge_addr_from =0 ; - } +if (damos_skip_charged_region (t, &r, s)) +continue ;if (!damos_valid_target (c, t, r, s))continue ;/* Apply the scheme */ + sz =damon_sz_region (r);if (c->ops.apply_scheme) {if (quota->esz && quota->charged_sz + sz > quota->esz) {
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 3/18 mm/damon/core: split damos application logic into a new function
In reply to SeongJae ParkThe DAMOS action applying function, 'damon_do_apply_schemes()', is still long and not easy to read. Split out the code for applying a single action to a single region into a new function for better readability.
--- mm/damon/core.c | 72 ++++++++++++++++++++++++++----------------------- 1 file changed, 39 insertions(+), 33 deletions(-)
mm/damon/core.c +39 -33
@@ -748,6 +748,44 @@ static bool damos_skip_charged_region(struct damon_target *t,return false; } +static void damos_apply_scheme (struct damon_ctx *c,struct damon_target *t, +struct damon_region *r,struct damos *s) +{ +struct damos_quota *quota = &s->quota; +unsigned long sz =damon_sz_region (r); +struct timespec64 begin, end; +unsigned long sz_applied =0 ; + +if (c->ops.apply_scheme) { +if (quota->esz && quota->charged_sz + sz > quota->esz) { + sz =ALIGN_DOWN (quota->esz - quota->charged_sz, +DAMON_MIN_REGION ); +if (!sz) + goto update_stat; +damon_split_region_at (t, r, sz); + } +ktime_get_coarse_ts64 (&begin); + sz_applied = c->ops.apply_scheme (c, t, r, s); +ktime_get_coarse_ts64 (&end); + quota->total_charged_ns +=timespec64_to_ns (&end) - +timespec64_to_ns (&begin); + quota->charged_sz += sz; +if (quota->esz && quota->charged_sz >= quota->esz) { + quota->charge_target_from = t; + quota->charge_addr_from = r->ar.end +1 ; + } + } +if (s->action !=DAMOS_STAT ) + r->age =0 ; + +update_stat: + s->stat.nr_tried++; + s->stat.sz_tried += sz; +if (sz_applied) + s->stat.nr_applied++; + s->stat.sz_applied += sz_applied; +} +static void damon_do_apply_schemes (struct damon_ctx *c,struct damon_target *t,struct damon_region *r)
@@ -756,9 +794,6 @@ static void damon_do_apply_schemes(struct damon_ctx *c,damon_for_each_scheme (s, c) {struct damos_quota *quota = &s->quota; -unsigned long sz; -struct timespec64 begin, end; -unsigned long sz_applied =0 ;if (!s->wmarks.activated)continue ;
@@ -774,36 +809,7 @@ static void damon_do_apply_schemes(struct damon_ctx *c,continue ;/* Apply the scheme */ - sz =damon_sz_region (r); -if (c->ops.apply_scheme) { -if (quota->esz && - quota->charged_sz + sz > quota->esz) { - sz =ALIGN_DOWN (quota->esz - quota->charged_sz, -DAMON_MIN_REGION ); -if (!sz) - goto update_stat; -damon_split_region_at (t, r, sz); - } -ktime_get_coarse_ts64 (&begin); - sz_applied = c->ops.apply_scheme (c, t, r, s); -ktime_get_coarse_ts64 (&end); - quota->total_charged_ns +=timespec64_to_ns (&end) - -timespec64_to_ns (&begin); - quota->charged_sz += sz; -if (quota->esz && quota->charged_sz >= quota->esz) { - quota->charge_target_from = t; - quota->charge_addr_from = r->ar.end +1 ; - } - } -if (s->action !=DAMOS_STAT ) - r->age =0 ; - -update_stat: - s->stat.nr_tried++; - s->stat.sz_tried += sz; -if (sz_applied) - s->stat.nr_applied++; - s->stat.sz_applied += sz_applied; +damos_apply_scheme (c, t, r, s); } }
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 4/18 mm/damon/core: split out scheme stat update logic into a new function
In reply to SeongJae ParkThe function for applying a given DAMON scheme action to a given DAMON region, 'damos_apply_scheme()' is not quite short. Make it better to read by splitting out the stat update logic into a new function.
--- mm/damon/core.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-)
mm/damon/core.c +11 -6
@@ -748,6 +748,16 @@ static bool damos_skip_charged_region(struct damon_target *t,return false; } +static void damos_update_stat (struct damos *s, +unsigned long sz_tried,unsigned long sz_applied) +{ + s->stat.nr_tried++; + s->stat.sz_tried += sz_tried; +if (sz_applied) + s->stat.nr_applied++; + s->stat.sz_applied += sz_applied; +} +static void damos_apply_scheme (struct damon_ctx *c,struct damon_target *t,struct damon_region *r,struct damos *s) {
@@ -779,11 +789,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t, r->age =0 ; update_stat: - s->stat.nr_tried++; - s->stat.sz_tried += sz; -if (sz_applied) - s->stat.nr_applied++; - s->stat.sz_applied += sz_applied; +damos_update_stat (s, sz, sz_applied); } static void damon_do_apply_schemes(struct damon_ctx *c,
@@ -808,7 +814,6 @@ static void damon_do_apply_schemes(struct damon_ctx *c,if (!damos_valid_target (c, t, r, s))continue ; -/* Apply the scheme */ damos_apply_scheme (c, t, r, s); } }
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 5/18 mm/damon/core: split out scheme quota adjustment logic into a new function
In reply to SeongJae ParkDAMOS quota adjustment logic in 'kdamond_apply_schemes()', has some amount of code, and the logic is not so straightforward. Split it out to a new function for better readability.
--- mm/damon/core.c | 91 ++++++++++++++++++++++++++----------------------- 1 file changed, 48 insertions(+), 43 deletions(-)
mm/damon/core.c +48 -43
@@ -841,59 +841,64 @@ static void damos_set_effective_quota(struct damos_quota *quota) quota->esz = esz; } -static void kdamond_apply_schemes (struct damon_ctx *c) +static void damos_adjust_quota (struct damon_ctx *c,struct damos *s) { +struct damos_quota *quota = &s->quota;struct damon_target *t; -struct damon_region *r, *next_r; -struct damos *s; +struct damon_region *r; +unsigned long cumulated_sz; +unsigned int score, max_score =0 ; -damon_for_each_scheme (s, c) { -struct damos_quota *quota = &s->quota; -unsigned long cumulated_sz; -unsigned int score, max_score =0 ; +if (!quota->ms && !quota->sz) +return ; -if (!s->wmarks.activated) -continue ; +/* New charge window starts */ +if (time_after_eq (jiffies, quota->charged_from + +msecs_to_jiffies (quota->reset_interval))) { +if (quota->esz && quota->charged_sz >= quota->esz) + s->stat.qt_exceeds++; + quota->total_charged_sz += quota->charged_sz; + quota->charged_from = jiffies; + quota->charged_sz =0 ; +damos_set_effective_quota (quota); + } -if (!quota->ms && !quota->sz) -continue ; +if (!c->ops.get_scheme_score) +return ; -/* New charge window starts */ -if (time_after_eq (jiffies, quota->charged_from + -msecs_to_jiffies ( - quota->reset_interval))) { -if (quota->esz && quota->charged_sz >= quota->esz) - s->stat.qt_exceeds++; - quota->total_charged_sz += quota->charged_sz; - quota->charged_from = jiffies; - quota->charged_sz =0 ; -damos_set_effective_quota (quota); +/* Fill up the score histogram */ +memset (quota->histogram,0 ,sizeof (quota->histogram)); +damon_for_each_target (t, c) { +damon_for_each_region (r, t) { +if (!__damos_valid_target (r, s)) +continue ; + score = c->ops.get_scheme_score (c, t, r, s); + quota->histogram[score] +=damon_sz_region (r); +if (score > max_score) + max_score = score; } + } -if (!c->ops.get_scheme_score) -continue ; +/* Set the min score limit */ +for (cumulated_sz =0 , score = max_score; ; score--) { + cumulated_sz += quota->histogram[score]; +if (cumulated_sz >= quota->esz || !score) +break ; + } + quota->min_score = score; +} -/* Fill up the score histogram */ -memset (quota->histogram,0 ,sizeof (quota->histogram)); -damon_for_each_target (t, c) { -damon_for_each_region (r, t) { -if (!__damos_valid_target (r, s)) -continue ; - score = c->ops.get_scheme_score ( - c, t, r, s); - quota->histogram[score] +=damon_sz_region (r); -if (score > max_score) - max_score = score; - } - } +static void kdamond_apply_schemes (struct damon_ctx *c) +{ +struct damon_target *t; +struct damon_region *r, *next_r; +struct damos *s; -/* Set the min score limit */ -for (cumulated_sz =0 , score = max_score; ; score--) { - cumulated_sz += quota->histogram[score]; -if (cumulated_sz >= quota->esz || !score) -break ; - } - quota->min_score = score; +damon_for_each_scheme (s, c) { +if (!s->wmarks.activated) +continue ; + +damos_adjust_quota (c, s); }damon_for_each_target (t, c) {
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 6/18 mm/damon/core: add a DAMON callback for scheme target regions check
In reply to SeongJae ParkFor deep level investigation of DAMON, knowing exactly to what regions each DAMON-based operation scheme is applied is helpful. It can also be very helpful for efficient monitoring results passing when the user has interest in regions of specific access patterns. Add a new DAMON callback that will be called before each scheme is applied to each region, to provide the functionality to the kernel API users.
--- include/linux/damon.h | 5 +++++ mm/damon/core.c | 6 +++++- 2 files changed, 10 insertions(+), 1 deletion(-)
include/linux/damon.h +5 -0
@@ -357,6 +357,7 @@ struct damon_operations {* @after_wmarks_check: Called after each schemes' watermarks check. * @after_sampling: Called after each sampling. * @after_aggregation: Called after each aggregation. +* @before_damos_apply: Called before applying DAMOS action. * @before_terminate: Called before terminating the monitoring. * @private: User private data. *
@@ -385,6 +386,10 @@ struct damon_callback {int (*after_wmarks_check)(struct damon_ctx *context);int (*after_sampling)(struct damon_ctx *context);int (*after_aggregation)(struct damon_ctx *context); +int (*before_damos_apply)(struct damon_ctx *context, +struct damon_target *target, +struct damon_region *region, +struct damos *scheme);void (*before_terminate)(struct damon_ctx *context); };
mm/damon/core.c +5 -1
@@ -765,6 +765,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,unsigned long sz =damon_sz_region (r);struct timespec64 begin, end;unsigned long sz_applied =0 ; +int err =0 ;if (c->ops.apply_scheme) {if (quota->esz && quota->charged_sz + sz > quota->esz) {
@@ -775,7 +776,10 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,damon_split_region_at (t, r, sz); }ktime_get_coarse_ts64 (&begin); - sz_applied = c->ops.apply_scheme (c, t, r, s); +if (c->callback.before_damos_apply) + err = c->callback.before_damos_apply (c, t, r, s); +if (!err) + sz_applied = c->ops.apply_scheme (c, t, r, s);ktime_get_coarse_ts64 (&end); quota->total_charged_ns +=timespec64_to_ns (&end) -timespec64_to_ns (&begin);
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 7/18 mm/damon/sysfs: Use damon_addr_range for regions' start and end values
In reply to SeongJae ParkDAMON has a struct for each address range but DAMON sysfs interface is using the low type (unsigned long) for storing the start and end addresses of regions. Use the dedicated struct for better type safety.
--- mm/damon/sysfs.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-)
mm/damon/sysfs.c +11 -14
@@ -1062,13 +1062,11 @@ static struct kobj_type damon_sysfs_schemes_ktype = {struct damon_sysfs_region {struct kobject kobj; -unsigned long start; -unsigned long end; +struct damon_addr_range ar; };static struct damon_sysfs_region *damon_sysfs_region_alloc ( -unsigned long start, -unsigned long end) +struct damon_addr_range ar) {struct damon_sysfs_region *region =kmalloc (sizeof (*region),GFP_KERNEL );
@@ -1076,8 +1074,7 @@ static struct damon_sysfs_region *damon_sysfs_region_alloc(if (!region)return NULL ; region->kobj = (struct kobject ){}; - region->start = start; - region->end = end; + region->ar = ar;return region; }
@@ -1087,7 +1084,7 @@ static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -return sysfs_emit (buf,"%lu\n" , region->start); +return sysfs_emit (buf,"%lu\n" , region->ar.start); } static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr,
@@ -1095,7 +1092,7 @@ static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr, {struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -int err =kstrtoul (buf,0 , ®ion->start); +int err =kstrtoul (buf,0 , ®ion->ar.start);return err ? err : count; }
@@ -1106,7 +1103,7 @@ static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr,struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -return sysfs_emit (buf,"%lu\n" , region->end); +return sysfs_emit (buf,"%lu\n" , region->ar.end); } static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr,
@@ -1114,7 +1111,7 @@ static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr, {struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -int err =kstrtoul (buf,0 , ®ion->end); +int err =kstrtoul (buf,0 , ®ion->ar.end);return err ? err : count; }
@@ -1187,7 +1184,7 @@ static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions, regions->regions_arr = regions_arr;for (i =0 ; i < nr_regions; i++) { - region =damon_sysfs_region_alloc (0 ,0 ); + region =damon_sysfs_region_alloc ((struct damon_addr_range ){});if (!region) {damon_sysfs_regions_rm_dirs (regions);return -ENOMEM ;
@@ -2147,11 +2144,11 @@ static int damon_sysfs_set_regions(struct damon_target *t,struct damon_sysfs_region *sys_region = sysfs_regions->regions_arr[i]; -if (sys_region->start > sys_region->end) +if (sys_region->ar.start > sys_region->ar.end) goto out; - ranges[i].start = sys_region->start; - ranges[i].end = sys_region->end; + ranges[i].start = sys_region->ar.start; + ranges[i].end = sys_region->ar.end;if (i ==0 )continue ;if (ranges[i -1 ].end > ranges[i].start)
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 8/18 mm/damon/sysfs: remove parameters of damon_sysfs_region_alloc()
In reply to SeongJae Park'damon_sysfs_region_alloc()' is always called with zero-filled 'struct damon_addr_range', because the start and end addresses should set by users. Remove unnecessary parameters of the function and simplify the body by using 'kzalloc()'.
--- mm/damon/sysfs.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-)
mm/damon/sysfs.c +3 -11
@@ -1065,17 +1065,9 @@ struct damon_sysfs_region {struct damon_addr_range ar; }; -static struct damon_sysfs_region *damon_sysfs_region_alloc ( -struct damon_addr_range ar) +static struct damon_sysfs_region *damon_sysfs_region_alloc (void ) { -struct damon_sysfs_region *region =kmalloc (sizeof (*region), -GFP_KERNEL ); - -if (!region) -return NULL ; - region->kobj = (struct kobject ){}; - region->ar = ar; -return region; +return kzalloc (sizeof (struct damon_sysfs_region ),GFP_KERNEL ); } static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,
@@ -1184,7 +1176,7 @@ static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions, regions->regions_arr = regions_arr;for (i =0 ; i < nr_regions; i++) { - region =damon_sysfs_region_alloc ((struct damon_addr_range ){}); + region =damon_sysfs_region_alloc ();if (!region) {damon_sysfs_regions_rm_dirs (regions);return -ENOMEM ;
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 9/18 mm/damon/sysfs: move sysfs_lock to common module
In reply to SeongJae ParkDAMON sysfs interface is implemented in a single file, sysfs.c, which has about 2,800 lines of code. As the interface is hierarchical and some of the code can be reused by different hierarchies, it would make more sense to split the implementation into common parts and different parts in multiple files. As the beginning of the work, create files for common code and move the global mutex for directories modifications protection into the files.
--- mm/damon/Makefile | 2 +- mm/damon/sysfs-common.c | 11 +++++++++++ mm/damon/sysfs-common.h | 11 +++++++++++ mm/damon/sysfs.c | 4 +--- 4 files changed, 24 insertions(+), 4 deletions(-) create mode 100644 mm/damon/sysfs-common.c create mode 100644 mm/damon/sysfs-common.h
mm/damon/Makefile +1 -1
@@ -3,7 +3,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_SYSFS) += sysfs.o +obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o obj-$(CONFIG_DAMON_RECLAIM) += modules-common.o reclaim.o obj-$(CONFIG_DAMON_LRU_SORT) += modules-common.o lru_sort.o
mm/damon/sysfs-common.c new file +11 -0
@@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Common Primitives for DAMON Sysfs Interface +* +* Author: SeongJae Park <[email protected]> +*/ + +#include "sysfs-common.h" + +DEFINE_MUTEX (damon_sysfs_lock); +
mm/damon/sysfs-common.h new file +11 -0
@@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Common Primitives for DAMON Sysfs Interface +* +* Author: SeongJae Park <[email protected]> +*/ + +#include <linux/damon.h> +#include <linux/kobject.h> + +extern struct mutex damon_sysfs_lock;
mm/damon/sysfs.c +1 -3
@@ -5,13 +5,11 @@* Copyright (c) 2022 SeongJae Park <[email protected]> */ -#include <linux/damon.h> -#include <linux/kobject.h> #include <linux/pid.h> #include <linux/sched.h> #include <linux/slab.h> -static DEFINE_MUTEX (damon_sysfs_lock); +#include "sysfs-common.h" /* * unsigned long range directory
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 10/18 mm/damon/sysfs: move unsigned long range directory to common module
In reply to SeongJae ParkThe implementation of unsigned long type range directories can be reused by multiple DAMON sysfs directories including those for DAMON-based Operation Schemes and the range of number of monitoring regions. Move the code into the files for DAMON sysfs common logics.
--- mm/damon/sysfs-common.c | 96 ++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs-common.h | 13 ++++++ mm/damon/sysfs.c | 100 ---------------------------------------- 3 files changed, 109 insertions(+), 100 deletions(-)
mm/damon/sysfs-common.c +96 -0
@@ -5,7 +5,103 @@* Author: SeongJae Park <[email protected]> */ +#include <linux/slab.h> +#include "sysfs-common.h" DEFINE_MUTEX (damon_sysfs_lock); +/* +* unsigned long range directory +*/ + +struct damon_sysfs_ul_range *damon_sysfs_ul_range_alloc ( +unsigned long min, +unsigned long max) +{ +struct damon_sysfs_ul_range *range =kmalloc (sizeof (*range), +GFP_KERNEL ); + +if (!range) +return NULL ; + range->kobj = (struct kobject ){}; + range->min = min; + range->max = max; + +return range; +} + +static ssize_t min_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); + +return sysfs_emit (buf,"%lu\n" , range->min); +} + +static ssize_t min_store (struct kobject *kobj,struct kobj_attribute *attr, +const char *buf,size_t count) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); +unsigned long min; +int err; + + err =kstrtoul (buf,0 , &min); +if (err) +return err; + + range->min = min; +return count; +} + +static ssize_t max_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); + +return sysfs_emit (buf,"%lu\n" , range->max); +} + +static ssize_t max_store (struct kobject *kobj,struct kobj_attribute *attr, +const char *buf,size_t count) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); +unsigned long max; +int err; + + err =kstrtoul (buf,0 , &max); +if (err) +return err; + + range->max = max; +return count; +} + +void damon_sysfs_ul_range_release (struct kobject *kobj) +{ +kfree (container_of(kobj ,struct damon_sysfs_ul_range ,kobj )); +} + +static struct kobj_attribute damon_sysfs_ul_range_min_attr = +__ATTR_RW_MODE (min,0600 ); + +static struct kobj_attribute damon_sysfs_ul_range_max_attr = +__ATTR_RW_MODE (max,0600 ); + +static struct attribute *damon_sysfs_ul_range_attrs[] = { + &damon_sysfs_ul_range_min_attr.attr, + &damon_sysfs_ul_range_max_attr.attr, +NULL , +}; +ATTRIBUTE_GROUPS (damon_sysfs_ul_range); + +struct kobj_type damon_sysfs_ul_range_ktype = { + .release = damon_sysfs_ul_range_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = damon_sysfs_ul_range_groups, +}; +
mm/damon/sysfs-common.h +13 -0
@@ -9,3 +9,16 @@#include <linux/kobject.h> extern struct mutex damon_sysfs_lock; + +struct damon_sysfs_ul_range { +struct kobject kobj; +unsigned long min; +unsigned long max; +}; + +struct damon_sysfs_ul_range *damon_sysfs_ul_range_alloc ( +unsigned long min, +unsigned long max); +void damon_sysfs_ul_range_release (struct kobject *kobj); + +extern struct kobj_type damon_sysfs_ul_range_ktype;
mm/damon/sysfs.c +0 -100
106 lines not on this page · raw message
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 11/18 mm/damon/sysfs: split out kdamond-independent schemes stats update logic into a new function
In reply to SeongJae Park'damon_sysfs_schemes_update_stats()' is coupled with both damon_sysfs_kdamond and damon_sysfs_schemes. It's a wide range of types dependency. It makes splitting the logics a little bit distracting. Split the function so that each function is coupled with smaller range of types.
--- mm/damon/sysfs.c | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-)
mm/damon/sysfs.c +21 -14
@@ -2204,6 +2204,25 @@ static void damon_sysfs_before_terminate(struct damon_ctx *ctx)mutex_unlock (&ctx->kdamond_lock); } +static void damon_sysfs_schemes_update_stats ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx) +{ +struct damos *scheme; +int schemes_idx =0 ; + +damon_for_each_scheme (scheme, ctx) { +struct damon_sysfs_stats *sysfs_stats; + + sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats; + sysfs_stats->nr_tried = scheme->stat.nr_tried; + sysfs_stats->sz_tried = scheme->stat.sz_tried; + sysfs_stats->nr_applied = scheme->stat.nr_applied; + sysfs_stats->sz_applied = scheme->stat.sz_applied; + sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds; + } +} +/* * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. * @kdamond: The kobject wrapper that associated to the kdamond thread.
@@ -2216,23 +2235,11 @@ static void damon_sysfs_before_terminate(struct damon_ctx *ctx)static int damon_sysfs_upd_schemes_stats (struct damon_sysfs_kdamond *kdamond) {struct damon_ctx *ctx = kdamond->damon_ctx; -struct damon_sysfs_schemes *sysfs_schemes; -struct damos *scheme; -int schemes_idx =0 ;if (!ctx)return -EINVAL ; - sysfs_schemes = kdamond->contexts->contexts_arr[0 ]->schemes; -damon_for_each_scheme (scheme, ctx) { -struct damon_sysfs_stats *sysfs_stats; - - sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats; - sysfs_stats->nr_tried = scheme->stat.nr_tried; - sysfs_stats->sz_tried = scheme->stat.sz_tried; - sysfs_stats->nr_applied = scheme->stat.nr_applied; - sysfs_stats->sz_applied = scheme->stat.sz_applied; - sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds; - } +damon_sysfs_schemes_update_stats ( + kdamond->contexts->contexts_arr[0 ]->schemes, ctx);return 0 ; }
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 12/18 mm/damon/sysfs: move schemes directory implementation to separate module
In reply to SeongJae ParkDAMON sysfs interface for 'schemes' directory is implemented using about thousand lines of code. It has no strong dependency with other parts of its file, so split it out to another file for better code management.
--- mm/damon/Makefile | 2 +- mm/damon/sysfs-common.h | 22 + mm/damon/sysfs-schemes.c | 1022 ++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs.c | 1018 ------------------------------------- 4 files changed, 1045 insertions(+), 1019 deletions(-) create mode 100644 mm/damon/sysfs-schemes.c
mm/damon/Makefile +1 -1
@@ -3,7 +3,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_SYSFS) += sysfs-common.o sysfs.o +obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs-schemes.o sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o obj-$(CONFIG_DAMON_RECLAIM) += modules-common.o reclaim.o obj-$(CONFIG_DAMON_LRU_SORT) += modules-common.o lru_sort.o
mm/damon/sysfs-common.h +22 -0
@@ -22,3 +22,25 @@ struct damon_sysfs_ul_range *damon_sysfs_ul_range_alloc(void damon_sysfs_ul_range_release (struct kobject *kobj);extern struct kobj_type damon_sysfs_ul_range_ktype; + +/* +* schemes directory +*/ + +struct damon_sysfs_schemes { +struct kobject kobj; +struct damon_sysfs_scheme **schemes_arr; +int nr; +}; + +struct damon_sysfs_schemes *damon_sysfs_schemes_alloc (void ); +void damon_sysfs_schemes_rm_dirs (struct damon_sysfs_schemes *schemes); + +extern struct kobj_type damon_sysfs_schemes_ktype; + +int damon_sysfs_set_schemes (struct damon_ctx *ctx, +struct damon_sysfs_schemes *sysfs_schemes); + +void damon_sysfs_schemes_update_stats ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx);
mm/damon/sysfs-schemes.c new file +1022 -0
1,022 lines not on this page · raw message
mm/damon/sysfs.c +0 -1018
1,036 lines not on this page · raw message
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 13/18 mm/damon/sysfs-schemes: implement schemes/tried_regions directory
In reply to SeongJae ParkFor deep level investigation of DAMON and efficient query-like monitoring results reading, DAMON kernel API (include/linux/damon.h) users can use 'before_damos_apply' DAMON callback. However, DAMON sysfs interface users don't have such option. Add a directory, namely 'tried_regions', under each scheme directory to use it as the interface for the purpose. That is, users will be able to signal DAMON to fill the directory with the regions that corresponding scheme has tried to be applied. By setting the access pattern of the scheme, users could do the efficient query-like monitoring. Note that this commit is implementing only the directory but the data filling.
--- mm/damon/sysfs-schemes.c | 57 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+)
mm/damon/sysfs-schemes.c +57 -0
@@ -9,6 +9,36 @@#include "sysfs-common.h" +/* +* scheme regions directory +*/ + +struct damon_sysfs_scheme_regions { +struct kobject kobj; +}; + +static struct damon_sysfs_scheme_regions * +damon_sysfs_scheme_regions_alloc (void ) +{ +return kzalloc (sizeof (struct damon_sysfs_scheme_regions ),GFP_KERNEL ); +} + +static void damon_sysfs_scheme_regions_release (struct kobject *kobj) +{ +kfree (container_of(kobj ,struct damon_sysfs_scheme_regions ,kobj )); +} + +static struct attribute *damon_sysfs_scheme_regions_attrs[] = { +NULL , +}; +ATTRIBUTE_GROUPS (damon_sysfs_scheme_regions); + +static struct kobj_type damon_sysfs_scheme_regions_ktype = { + .release = damon_sysfs_scheme_regions_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = damon_sysfs_scheme_regions_groups, +}; +/* * schemes/stats directory */
@@ -635,6 +665,7 @@ struct damon_sysfs_scheme {struct damon_sysfs_quotas *quotas;struct damon_sysfs_watermarks *watermarks;struct damon_sysfs_stats *stats; +struct damon_sysfs_scheme_regions *tried_regions; };/* This should match with enum damos_action */
@@ -743,6 +774,25 @@ static int damon_sysfs_scheme_set_stats(struct damon_sysfs_scheme *scheme)return err; } +static int damon_sysfs_scheme_set_tried_regions ( +struct damon_sysfs_scheme *scheme) +{ +struct damon_sysfs_scheme_regions *tried_regions = +damon_sysfs_scheme_regions_alloc (); +int err; + +if (!tried_regions) +return -ENOMEM ; + err =kobject_init_and_add (&tried_regions->kobj, + &damon_sysfs_scheme_regions_ktype, &scheme->kobj, +"tried_regions" ); +if (err) +kobject_put (&tried_regions->kobj); +else + scheme->tried_regions = tried_regions; +return err; +} +static int damon_sysfs_scheme_add_dirs (struct damon_sysfs_scheme *scheme) {int err;
@@ -759,8 +809,14 @@ static int damon_sysfs_scheme_add_dirs(struct damon_sysfs_scheme *scheme) err =damon_sysfs_scheme_set_stats (scheme);if (err) goto put_watermarks_quotas_access_pattern_out; + err =damon_sysfs_scheme_set_tried_regions (scheme); +if (err) + goto put_tried_regions_out;return 0 ; +put_tried_regions_out: +kobject_put (&scheme->tried_regions->kobj); + scheme->tried_regions =NULL ; put_watermarks_quotas_access_pattern_out:kobject_put (&scheme->watermarks->kobj); scheme->watermarks =NULL ;
@@ -781,6 +837,7 @@ static void damon_sysfs_scheme_rm_dirs(struct damon_sysfs_scheme *scheme)kobject_put (&scheme->quotas->kobj);kobject_put (&scheme->watermarks->kobj);kobject_put (&scheme->stats->kobj); +kobject_put (&scheme->tried_regions->kobj); } static ssize_t action_show(struct kobject *kobj, struct kobj_attribute *attr,
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 14/18 mm/damon/sysfs-schemes: implement scheme region directory
In reply to SeongJae ParkImplement code for each region directory under 'tried_regions' directory of each scheme directory. This directory will provide the address range, the monitored access frequency ('nr_accesses'), and the age of each DAMON region that corresponding DAMON-based operation scheme has tried to be applied. Note that this commit doesn't implement the code for filling the data but the sysfs directory.
--- mm/damon/sysfs-schemes.c | 123 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 122 insertions(+), 1 deletion(-)
mm/damon/sysfs-schemes.c +122 -1
@@ -9,18 +9,138 @@#include "sysfs-common.h" +/* +* scheme region directory +*/ + +struct damon_sysfs_scheme_region { +struct kobject kobj; +struct damon_addr_range ar; +unsigned int nr_accesses; +unsigned int age; +struct list_head list; +}; + +static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc ( +struct damon_region *region) +{ +struct damon_sysfs_scheme_region *sysfs_region =kmalloc ( +sizeof (*sysfs_region),GFP_KERNEL ); + +if (!sysfs_region) +return NULL ; + sysfs_region->kobj = (struct kobject ){}; + sysfs_region->ar = region->ar; + sysfs_region->nr_accesses = region->nr_accesses; + sysfs_region->age = region->age; +INIT_LIST_HEAD (&sysfs_region->list); +return sysfs_region; +} + +static ssize_t start_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_scheme_region *region =container_of (kobj, + struct damon_sysfs_scheme_region, kobj); + +return sysfs_emit (buf,"%lu\n" , region->ar.start); +} + +static ssize_t end_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_scheme_region *region =container_of (kobj, + struct damon_sysfs_scheme_region, kobj); + +return sysfs_emit (buf,"%lu\n" , region->ar.end); +} + +static ssize_t nr_accesses_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +struct damon_sysfs_scheme_region *region =container_of (kobj, + struct damon_sysfs_scheme_region, kobj); + +return sysfs_emit (buf,"%u\n" , region->nr_accesses); +} + +static ssize_t age_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_scheme_region *region =container_of (kobj, + struct damon_sysfs_scheme_region, kobj); + +return sysfs_emit (buf,"%u\n" , region->age); +} + +static void damon_sysfs_scheme_region_release (struct kobject *kobj) +{ +struct damon_sysfs_scheme_region *region =container_of (kobj, + struct damon_sysfs_scheme_region, kobj); + +list_del (®ion->list); +kfree (region); +} + +static struct kobj_attribute damon_sysfs_scheme_region_start_attr = +__ATTR_RO_MODE (start,0400 ); + +static struct kobj_attribute damon_sysfs_scheme_region_end_attr = +__ATTR_RO_MODE (end,0400 ); + +static struct kobj_attribute damon_sysfs_scheme_region_nr_accesses_attr = +__ATTR_RO_MODE (nr_accesses,0400 ); + +static struct kobj_attribute damon_sysfs_scheme_region_age_attr = +__ATTR_RO_MODE (age,0400 ); + +static struct attribute *damon_sysfs_scheme_region_attrs[] = { + &damon_sysfs_scheme_region_start_attr.attr, + &damon_sysfs_scheme_region_end_attr.attr, + &damon_sysfs_scheme_region_nr_accesses_attr.attr, + &damon_sysfs_scheme_region_age_attr.attr, +NULL , +}; +ATTRIBUTE_GROUPS (damon_sysfs_scheme_region); + +static struct kobj_type damon_sysfs_scheme_region_ktype = { + .release = damon_sysfs_scheme_region_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = damon_sysfs_scheme_region_groups, +}; +/* * scheme regions directory */ struct damon_sysfs_scheme_regions {struct kobject kobj; +struct list_head regions_list; +int nr_regions; };static struct damon_sysfs_scheme_regions *damon_sysfs_scheme_regions_alloc (void ) { -return kzalloc (sizeof (struct damon_sysfs_scheme_regions ),GFP_KERNEL ); +struct damon_sysfs_scheme_regions *regions =kmalloc (sizeof (*regions), +GFP_KERNEL ); + + regions->kobj = (struct kobject ){}; +INIT_LIST_HEAD (®ions->regions_list); + regions->nr_regions =0 ; +return regions; +} + +static void damon_sysfs_scheme_regions_rm_dirs ( +struct damon_sysfs_scheme_regions *regions) +{ +struct damon_sysfs_scheme_region *r, *next; + +list_for_each_entry_safe (r, next, ®ions->regions_list, list) { +/* release function deletes it from the list */ +kobject_put (&r->kobj); + regions->nr_regions--; + } }static void damon_sysfs_scheme_regions_release (struct kobject *kobj)
@@ -837,6 +957,7 @@ static void damon_sysfs_scheme_rm_dirs(struct damon_sysfs_scheme *scheme)kobject_put (&scheme->quotas->kobj);kobject_put (&scheme->watermarks->kobj);kobject_put (&scheme->stats->kobj); +damon_sysfs_scheme_regions_rm_dirs (scheme->tried_regions);kobject_put (&scheme->tried_regions->kobj); }
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 15/18 mm/damon/sysfs: implement DAMOS-tried regions update command
In reply to SeongJae ParkImplement filling of the data for 'tried_regions' directory of DAMON-based operation schemes for specific kdamond. With this commit, DAMON sysfs interface users can write a special keyword, 'update_schemes_regions' to the 'state' file of the kdamond directory to signal DAMON to fill the relevant 'tried_regions' directories. In detail, once the keyword is written, DAMON sysfs interface will collect the information using the 'before_damos_apply()' callback for one aggregation interval and populate scheme region directories with the values.
--- mm/damon/sysfs-common.h | 6 ++++ mm/damon/sysfs-schemes.c | 64 ++++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs.c | 54 +++++++++++++++++++++++++++++++-- 3 files changed, 122 insertions(+), 2 deletions(-)
mm/damon/sysfs-common.h +6 -0
@@ -44,3 +44,9 @@ int damon_sysfs_set_schemes(struct damon_ctx *ctx,void damon_sysfs_schemes_update_stats (struct damon_sysfs_schemes *sysfs_schemes,struct damon_ctx *ctx); + +int damon_sysfs_schemes_update_regions_start ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx); + +int damon_sysfs_schemes_update_regions_stop (struct damon_ctx *ctx);
mm/damon/sysfs-schemes.c +64 -0
67 lines not on this page · raw message
mm/damon/sysfs.c +52 -2
99 lines not on this page · raw message
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 16/18 mm/damon/sysfs-schemes: implement DAMOS tried regions clear command
In reply to SeongJae ParkWhen there are huge number of DAMON regions that specific scheme actions are tried to be applied, directories and files under 'tried_regions' scheme directory could waste some memory. Add another special input keyword for 'state' file of each kdamond sysfs directory that can be used for cleanup of the 'tried_regions' sub-directories.
--- mm/damon/sysfs-common.h | 4 ++++ mm/damon/sysfs-schemes.c | 17 +++++++++++++++++ mm/damon/sysfs.c | 18 ++++++++++++++++++ 3 files changed, 39 insertions(+)
mm/damon/sysfs-common.h +4 -0
@@ -50,3 +50,7 @@ int damon_sysfs_schemes_update_regions_start( struct damon_ctx *ctx);int damon_sysfs_schemes_update_regions_stop (struct damon_ctx *ctx); + +int damon_sysfs_schemes_clear_regions ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx);
mm/damon/sysfs-schemes.c +17 -0
@@ -1262,3 +1262,20 @@ int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx) damon_sysfs_schemes_region_idx =0 ;return 0 ; } + +int damon_sysfs_schemes_clear_regions ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx) +{ +struct damos *scheme; +int schemes_idx =0 ; + +damon_for_each_scheme (scheme, ctx) { +struct damon_sysfs_scheme *sysfs_scheme; + + sysfs_scheme = sysfs_schemes->schemes_arr[schemes_idx++]; +damon_sysfs_scheme_regions_rm_dirs ( + sysfs_scheme->tried_regions); + } +return 0 ; +}
mm/damon/sysfs.c +18 -0
@@ -1001,6 +1001,9 @@ enum damon_sysfs_cmd {DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS ,/* @DAMON_SYSFS_CMD_UPDATE_SCHEMES_REGIONS: Update scheme regions */ DAMON_SYSFS_CMD_UPDATE_SCHEMES_REGIONS , +/* @DAMON_SYSFS_CMD_CLEAR_SCHEMES_REGIONS: Clear scheme regions */ + DAMON_SYSFS_CMD_CLEAR_SCHEMES_REGIONS, +/* * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands. */
@@ -1014,6 +1017,7 @@ static const char * const damon_sysfs_cmd_strs[] = {"commit" ,"update_schemes_stats" ,"update_schemes_regions" , + "clear_schemes_regions", };/*
@@ -1259,6 +1263,17 @@ static int damon_sysfs_upd_schemes_regions_stop(return damon_sysfs_schemes_update_regions_stop (ctx); } +static int damon_sysfs_clear_schemes_regions ( +struct damon_sysfs_kdamond *kdamond) +{ +struct damon_ctx *ctx = kdamond->damon_ctx; + +if (!ctx) +return -EINVAL ; +return damon_sysfs_schemes_clear_regions ( + kdamond->contexts->contexts_arr[0 ]->schemes, ctx); +} +static inline bool damon_sysfs_kdamond_running (struct damon_sysfs_kdamond *kdamond) {
@@ -1340,6 +1355,9 @@ static int damon_sysfs_cmd_request_callback(struct damon_ctx *c) damon_sysfs_schemes_regions_updating = false; }break ; +case DAMON_SYSFS_CMD_CLEAR_SCHEMES_REGIONS : + err =damon_sysfs_clear_schemes_regions (kdamond); +break ;default :break ; }
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 17/18 Docs/admin-guide/mm/damon/usage: document schemes/<s>/tried_regions directory
In reply to SeongJae ParkDocument 'tried_regions' directory in DAMON sysfs interface usage in the administrator guide.
--- Documentation/admin-guide/mm/damon/usage.rst | 44 ++++++++++++++++++-- 1 file changed, 41 insertions(+), 3 deletions(-)
Documentation/admin-guide/mm/damon/usage.rst +41 -3
@@ -88,6 +88,9 @@ comma (","). :: │ │ │ │ │ │ │ │ weights/sz_permil,nr_accesses_permil,age_permil │ │ │ │ │ │ │ watermarks/metric,interval_us,high,mid,low │ │ │ │ │ │ │ stats/nr_tried,sz_tried,nr_applied,sz_applied,qt_exceeds + │ │ │ │ │ │ │ tried_regions/ + │ │ │ │ │ │ │ │ 0/start,end,nr_accesses,age + │ │ │ │ │ │ │ │ ... │ │ │ │ │ │ ... │ │ │ │ ... │ │ ...
@@ -125,7 +128,14 @@ in the state. Writing ``commit`` to the ``state`` file makes kdamond reads the user inputs in the sysfs files except ``state`` file again. Writing ``update_schemes_stats`` to ``state`` file updates the contents of stats files for each DAMON-based operation scheme of the kdamond. For details of the -stats, please refer to :ref:`stats section <sysfs_schemes_stats>`. +stats, please refer to :ref:`stats section <sysfs_schemes_stats>`. Writing +``update_schemes_regions`` to ``state`` file updates the DAMON-based operation +scheme action tried regions directory for each DAMON-based operation scheme of +the kdamond. Writing ``clear_schemes_regions`` to ``state`` file clears the +DAMON-based operating scheme action tried regions directory for each +DAMON-based operation scheme of the kdamond. For details of the DAMON-based +operation scheme action tried regions directory, please refer to +:ref:tried_regions section <sysfs_schemes_tried_regions>`. If the state is ``on``, reading ``pid`` shows the pid of the kdamond thread.
@@ -166,6 +176,8 @@ You can set and get what type of monitoring operations DAMON will use for the context by writing one of the keywords listed in ``avail_operations`` file and reading from the ``operations`` file. +.. _sysfs_monitoring_attrs: + contexts/<N>/monitoring_attrs/ ------------------------------
@@ -252,8 +264,9 @@ to ``N-1``. Each directory represents each DAMON-based operation scheme. schemes/<N>/ ------------ -In each scheme directory, four directories (``access_pattern``, ``quotas``, -``watermarks``, and ``stats``) and one file (``action``) exist. +In each scheme directory, five directories (``access_pattern``, ``quotas``, +``watermarks``, ``stats``, and ``tried_regions``) and one file (``action``) +exist. The ``action`` file is for setting and getting what action you want to apply to memory regions having specific access pattern of the interest. The keywords
@@ -348,6 +361,31 @@ should ask DAMON sysfs interface to updte the content of the files for the stats by writing a special keyword, ``update_schemes_stats`` to the relevant ``kdamonds/<N>/state`` file. +.. _sysfs_schemes_tried_regions: + +schemes/<N>/tried_regions/ +-------------------------- + +When a special keyword, ``update_schemes_regions``, is written to the relevant +``kdamonds/<N>/state`` file, DAMON creates directories named integer starting +from ``0`` under this directory. Each directory contains files exposing +detailed information about each of the memory region that the corresponding +scheme's ``action`` has tried to be applied under this directory, during next +:ref:`aggregation interval <sysfs_monitoring_attrs>`. The information includes +address range, ``nr_accesses``, , and ``age`` of the region. + +The directories will be removed when another special keyword, +``clear_schemes_regions``, is written to the relevant ``kdamonds/<N>/state`` +file. + +tried_regions/<N>/ +------------------ + +In each region directory, you will find four files (``start``, ``end``, +``nr_accesses``, and ``age``). Reading the files will show the start and end +addresses, ``nr_accesses``, and ``age`` of the region that corresponding +DAMON-based operation scheme ``action`` has tried to be applied. + Example ~~~~~~~
Signature · 1 line
2.25.1
SeongJae Park
maintainerRFC PATCH 18/18 Docs/ABI/damon: document 'schemes/<s>/tried_regions' directory
In reply to SeongJae ParkUpdate DAMON ABI document for added 'tried_regions' directory of DAMON sysfs interface.
--- .../ABI/testing/sysfs-kernel-mm-damon | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+)
Documentation/ABI/testing/sysfs-kernel-mm-damon +32 -0
@@ -27,6 +27,10 @@ Description: Writing 'on' or 'off' to this file makes the kdamond starts or makes the kdamond reads the user inputs in the sysfs files except 'state' again. Writing 'update_schemes_stats' to the file updates contents of schemes stats files of the kdamond. + Writing 'update_schemes_regions' to the file updates contents + of 'tried_regions' directory of every scheme directory of this + kdamond. Writing 'clear_schemes_regions' to the file removes + contents of the 'tried_regions' directory. What: /sys/kernel/mm/damon/admin/kdamonds/<K>/pid Date: Mar 2022
@@ -283,3 +287,31 @@ Date: Mar 2022 Contact: SeongJae Park <[email protected]> Description: Reading this file returns the number of the exceed events of the scheme's quotas. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/tried_regions/<R>/start +Date: Oct 2022 +Contact: SeongJae Park <[email protected]> +Description: Reading this file returns the start address of a memory region + that corresponding DAMON-based Operation Scheme's action has + tried to be applied. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/tried_regions/<R>/end +Date: Oct 2022 +Contact: SeongJae Park <[email protected]> +Description: Reading this file returns the end address of a memory region + that corresponding DAMON-based Operation Scheme's action has + tried to be applied. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/tried_regions/<R>/nr_accesses +Date: Oct 2022 +Contact: SeongJae Park <[email protected]> +Description: Reading this file returns the 'nr_accesses' of a memory region + that corresponding DAMON-based Operation Scheme's action has + tried to be applied. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/tried_regions/<R>/age +Date: Oct 2022 +Contact: SeongJae Park <[email protected]> +Description: Reading this file returns the 'age' of a memory region that + corresponding DAMON-based Operation Scheme's action has tried + to be applied.
Signature · 1 line
2.25.1
SeongJae Park
maintainerQuoted 26 lines · On Wed, 19 Oct 2022 00:12:59 +0000 SeongJae Park <[email protected]> wrote:
DAMON users can retrieve the monitoring results via '
after_aggregation' callbacks if the user is using the kernel API, or 'damon_aggregated' tracepoint if the user is in the user space. Those are useful if full monitoring results are necessary. However, if the user has interest in only some regions having specific access pattern, the interfaces could be inefficient. For example, some DAMOS users might want to know exactly what regions were identified as fulfilling the access pattern of the scheme, for a debugging or a tuning.This patchset implements DAMON kernel API callbacks and sysfs directory for efficient exposure of the information. The new callback will be called for each region before specific DAMOS action is gonna tried to be applied. The sysfs directory will be called '
tried_regions' and placed under each scheme sysfs directory. User can write a special keyworkd, 'update_schemes_regions' to the 'state' file of a kdamond sysfs directory. Then, DAMON sysfs interface will fill the directory with the information of regions that corresponding scheme action was tried to be applied for one aggregation interval.Patches Sequence
----------------First five patches (1-5) clean up and refactor code that following patch will touch, and the following one (patch 6) implements the DAMON callback for DAMON kernel API users.
Quoted 8 lines
Following six patches (7-12) clean up and refactor the sysfs interface before the new sysfs directory introduction. Following two patches (13 and 14) implement the sysfs directories, and successing two patches (15 and 16) implement the special keyword for 'state' to fill and clean up the directories.
Finally, two more patches (17 and 18) for the documentation of the usage and ABI follow.
I think this patchset is unnecessarily big due to the cleanups and refactorings. I added them in this patchset mainly because I found the messy code while working for the feature. However, now it looks like it would make more sense to split them out into separate patchsets.
Just thinking loudly, but any input is welcome.
Thanks,
SJ
[...]