Implement Data Access Monitoring-based Memory Operation Schemes
Subsystems (6)
v9 cover Implement Data Access Monitoring-based Memory Operation Schemes
From: SeongJae Park <[email protected]>
DAMON[1] can be used as a primitive for data access awared memory management optimizations. For that, users who want such optimizations should run DAMON, read the monitoring results, analyze it, plan a new memory management scheme, and apply the new scheme by themselves. Such efforts will be inevitable for some complicated optimizations.
However, in many other cases, the users would simply want the system to apply a memory management action to a memory region of a specific size having a specific access frequency for a specific time. For example, "page out a memory region larger than 100 MiB keeping only rare accesses more than 2 minutes", or "Do not use THP for a memory region larger than 2 MiB rarely accessed for more than 1 seconds".
This RFC patchset makes DAMON to handle such data access monitoring-based operation schemes. With this change, users can do the data access aware optimizations by simply specifying their schemes to DAMON.
[1] https://lore.kernel.org/linux-mm/[email protected]/
Evaluations
===========
We evaluated DAMON's overhead, monitoring quality and usefulness using 25 realistic workloads on my QEMU/KVM based virtual machine.
DAMON is lightweight. It increases system memory usage by only -0.39% and consumes less than 1% CPU time in most case. It slows target workloads down by only 0.63%.
DAMON is accurate and useful for memory management optimizations. An experimental DAMON-based operation scheme for THP, 'ethp', removes 69.43% of THP memory overheads while preserving 37.11% of THP speedup. Another experimental DAMON-based 'proactive reclamation' implementation, 'prcl', reduces 89.30% of residential sets and 22.40% of system memory footprint while incurring only 1.98% runtime overhead in the best case (parsec3/freqmine).
NOTE that the experimentail THP optimization and proactive reclamation are not for production, just only for proof of concepts.
Please refer to the official document[1] or "Documentation/admin-guide/mm: Add a document for DAMON" patch in the latest DAMON patchset for detailed evaluation setup and results.
[1] https://damonitor.github.io/doc/html/latest-damos
More Information
================
We prepared a showcase web site[1] that you can get more information. There are
- the official documentations[2],
- the heatmap format dynamic access pattern of various realistic workloads for heap area[3], mmap()-ed area[4], and stack[5] area,
- the dynamic working set size distribution[6] and chronological working set size changes[7], and
- the latest performance test results[8].
[1] https://damonitor.github.io/_index
[2] https://damonitor.github.io/doc/html/latest-damos
[3] https://damonitor.github.io/test/result/visual/latest/heatmap.0.html
[4] https://damonitor.github.io/test/result/visual/latest/heatmap.1.html
[5] https://damonitor.github.io/test/result/visual/latest/heatmap.2.html
[6] https://damonitor.github.io/test/result/visual/latest/wss_sz.html
[7] https://damonitor.github.io/test/result/visual/latest/wss_time.html
[8] https://damonitor.github.io/test/result/perf/latest/html/index.html
Baseline and Complete Git Tree
==============================
The patches are based on the v5.6 plus v11 DAMON patchset[1] and Minchan's ``do_madvise()`` patch[2]. Minchan's patch was necessary for reuse of ``madvise()`` code in DAMON. You can also clone the complete git tree:
$ git clone git://github.com/sjp38/linux -b damos/rfc/v9
The web is also available:
https://github.com/sjp38/linux/releases/tag/damos/rfc/v9
There are a couple of trees for entire DAMON patchset series. It includes future features. The first one[3] contains the changes for latest release, while the other one[4] contains the changes for next release.
[1] https://lore.kernel.org/linux-mm/[email protected]/
[2] https://lore.kernel.org/linux-mm/[email protected]/
[3] https://github.com/sjp38/linux/tree/damon/master
[4] https://github.com/sjp38/linux/tree/damon/next
Sequence Of Patches
===================
The first patch allows DAMON to reuse ``madvise()`` code for the actions. The second patch accounts age of each region. The third patch implements the handling of the schemes in DAMON and exports a kernel space programming interface for it. The fourth patch implements a debugfs interface for the privileged people and programs. The fifth patch implements schemes statistics feature for easier tuning of the schemes and runtime access pattern analysis. The sixth patche adds selftests for these changes, and the seventhe patch adds human friendly schemes support to the user space tool for DAMON. Finally, the eighth patch documents this new feature in the document.
Patch History
=============
Changes from RFC v8
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rewrite the document (Stefan Nuernberger)
- Make 'damon_for_each_*' argument order consistent (Leonard Foerster)
- Implement statistics for schemes
- Avoid races between debugfs readers and writers
- Reset age for only significant access frequency changes
- Add kernel-doc comments in damon.h
Changes from RFC v7
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on DAMON v11 patchset
- Add documentation
Changes from RFC v6
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on DAMON v9 patchset
- Cleanup code and fix typos (Stefan Nuernberger)
Changes from RFC v5
(https://lore.kernel.org/linux-mm/[email protected]/)
- Rebase on DAMON v8 patchset
- Update test results
- Fix DAMON userspace tool crash on signal handling
- Fix checkpatch warnings
Changes from RFC v4
(https://lore.kernel.org/linux-mm/[email protected]/)
- Handle CONFIG_ADVISE_SYSCALL
- Clean up code (Jonathan Cameron)
- Update test results
- Rebase on v5.6 + DAMON v7
Changes from RFC v3
(https://lore.kernel.org/linux-mm/[email protected]/)
- Add Reviewed-by from Brendan Higgins
- Code cleanup: Modularize madvise() call
- Fix a trivial bug in the wrapper python script
- Add more stable and detailed evaluation results with updated ETHP scheme
Changes from RFC v2
(https://lore.kernel.org/linux-mm/[email protected]/)
- Fix aging mechanism for more better 'old region' selection
- Add more kunittests and kselftests for this patchset
- Support more human friedly description and application of 'schemes'
Changes from RFC v1
(https://lore.kernel.org/linux-mm/[email protected]/)
- Properly adjust age accounting related properties after splitting, merging, and action applying
SeongJae Park (8):
mm/madvise: Export do_madvise() to external GPL modules mm/damon: Account age of target regions
mm/damon: Implement data access monitoring-based operation schemes mm/damon/schemes: Implement a debugfs interface mm/damon/schemes: Implement statistics feature mm/damon/selftests: Add 'schemes' debugfs tests damon/tools: Support more human friendly 'schemes' control Documentation/admin-guide/mm: Document DAMON-based operation schemes
Documentation/admin-guide/mm/damon/guide.rst | 35 ++ Documentation/admin-guide/mm/damon/usage.rst | 126 +++++- include/linux/damon.h | 65 ++++ mm/damon.c | 361 +++++++++++++++++- mm/madvise.c | 1 + tools/damon/_convert_damos.py | 128 +++++++ tools/damon/_damon.py | 143 +++++++ tools/damon/damo | 7 + tools/damon/record.py | 135 +------ tools/damon/schemes.py | 105 +++++ .../testing/selftests/damon/debugfs_attrs.sh | 29 ++ 11 files changed, 992 insertions(+), 143 deletions(-) create mode 100755 tools/damon/_convert_damos.py create mode 100644 tools/damon/_damon.py create mode 100644 tools/damon/schemes.py
Signature · 1 line
2.17.1
RFC v9 1/8 mm/madvise: Export do_madvise() to external GPL modules
From: SeongJae Park <[email protected]>
This commit exports 'do_madvise()' to external GPL modules, so that other modules including DAMON could use the function.
--- mm/madvise.c | 1 + 1 file changed, 1 insertion(+)
mm/madvise.c +1 -0
@@ -1151,6 +1151,7 @@ int do_madvise(struct task_struct *target_task, struct mm_struct *mm,return error; } +EXPORT_SYMBOL_GPL (do_madvise); SYSCALL_DEFINE3(madvise, unsigned long, start, size_t, len_in, int, behavior) {
Signature · 1 line
2.17.1
RFC v9 2/8 mm/damon: Account age of target regions
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
DAMON can be used as a primitive for data access pattern aware memory management optimizations. However, users who want such optimizations should run DAMON, read the monitoring results, analyze it, plan a new memory management scheme, and apply the new scheme by themselves. It would not be too hard, but still require some level of effort. For complicated optimizations, this effort is inevitable.
That said, in many cases, users would simply want to apply an actions to a memory region of a specific size having a specific access frequency for a specific time. For example, "page out a memory region larger than 100 MiB but having a low access frequency more than 10 minutes", or "Use THP for a memory region larger than 2 MiB having a high access frequency for more than 2 seconds".
For such optimizations, users will need to first account the age of each region themselves. To reduce such efforts, this commit implements a simple age account of each region in DAMON. For each aggregation step, DAMON compares the access frequency with that from last aggregation and reset the age of the region if the change is significant. Else, the age is incremented. Also, in case of the merge of regions, the region size-weighted average of the ages is set as the age of merged new region.
--- include/linux/damon.h | 10 ++++++++++ mm/damon.c | 29 +++++++++++++++++++++-------- 2 files changed, 31 insertions(+), 8 deletions(-)
include/linux/damon.h +10 -0
@@ -24,6 +24,13 @@* @sampling_addr: Address of the sample for the next access check. * @nr_accesses: Access frequency of this region. * @list: List head for siblings. +* @age: Age of this region. +* @last_nr_accesses: Internal value for age calculation. +* +* @age is initially zero, increased for each aggregation interval, and reset +* to zero again if the access frequency is significantly changed. If two +* regions are merged into a new region, both @nr_accesses and @age of the new +* region are set as region size-weighted average of those of the two regions. */ struct damon_region {unsigned long vm_start;
@@ -31,6 +38,9 @@ struct damon_region {unsigned long sampling_addr;unsigned int nr_accesses;struct list_head list; + +unsigned int age; +unsigned int last_nr_accesses; };/**
mm/damon.c +21 -8
@@ -86,6 +86,9 @@ static struct damon_region *damon_new_region(struct damon_ctx *ctx, region->nr_accesses =0 ;INIT_LIST_HEAD (®ion->list); + region->age =0 ; + region->last_nr_accesses =0 ; +return region; }
@@ -659,6 +662,7 @@ static void kdamond_reset_aggregated(struct damon_ctx *c) sizeof(r->nr_accesses));trace_damon_aggregated (t->pid, nr, r->vm_start, r->vm_end, r->nr_accesses); + r->last_nr_accesses = r->nr_accesses; r->nr_accesses =0 ; } }
@@ -672,9 +676,11 @@ static void kdamond_reset_aggregated(struct damon_ctx *c)static void damon_merge_two_regions (struct damon_region *l,struct damon_region *r) { - l->nr_accesses = (l->nr_accesses *sz_damon_region (l) + - r->nr_accesses *sz_damon_region (r)) / - (sz_damon_region (l) +sz_damon_region (r)); +unsigned long sz_l =sz_damon_region (l), sz_r =sz_damon_region (r); + + l->nr_accesses = (l->nr_accesses * sz_l + r->nr_accesses * sz_r) / + (sz_l + sz_r); + l->age = (l->age * sz_l + r->age * sz_r) / (sz_l + sz_r); l->vm_end = r->vm_end;damon_destroy_region (r); }
@@ -692,12 +698,16 @@ static void damon_merge_regions_of(struct damon_task *t, unsigned int thres)struct damon_region *r, *prev =NULL , *next;damon_for_each_region_safe (r, next, t) { -if (!prev || prev->vm_end != r->vm_start || -diff_of (prev->nr_accesses, r->nr_accesses) > thres) { +if (diff_of (r->nr_accesses, r->last_nr_accesses) > thres) + r->age =0 ; +else + r->age++; + +if (prev && prev->vm_end == r->vm_start && +diff_of (prev->nr_accesses, r->nr_accesses) <= thres) +damon_merge_two_regions (prev, r); +else prev = r; -continue ; - } -damon_merge_two_regions (prev, r); } }
@@ -733,6 +743,9 @@ static void damon_split_region_at(struct damon_ctx *ctx, new =damon_new_region (ctx, r->vm_start + sz_r, r->vm_end); r->vm_end = new->vm_start; + new->age = r->age; + new->last_nr_accesses = r->last_nr_accesses; +damon_insert_region (new, r,damon_next_region (r)); }
Signature · 1 line
2.17.1
RFC v9 3/8 mm/damon: Implement data access monitoring-based operation schemes
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
In many cases, users might use DAMON for simple data access aware memory management optimizations such as applying an operation scheme to a memory region of a specific size having a specific access frequency for a specific time. For example, "page out a memory region larger than 100 MiB but having a low access frequency more than 10 minutes", or "Use THP for a memory region larger than 2 MiB having a high access frequency for more than 2 seconds".
To minimize users from spending their time for implementation of such simple data access monitoring-based operation schemes, this commit makes DAMON to handle such schemes directly. With this commit, users can simply specify their desired schemes to DAMON.
Each of the schemes is composed with conditions for filtering of the target memory regions and desired memory management action for the target. Specifically, the format is::
<min/max size> <min/max access frequency> <min/max age> <action>
The filtering conditions are size of memory region, number of accesses to the region monitored by DAMON, and the age of the region. The age of region is incremented periodically but reset when its addresses or access frequency has significantly changed or the action of a scheme was applied. For the action, current implementation supports only a few of madvise() hints, ``MADV_WILLNEED``, ``MADV_COLD``, ``MADV_PAGEOUT``, ``MADV_HUGEPAGE``, and ``MADV_NOHUGEPAGE``.
--- include/linux/damon.h | 49 ++++++++++++++ mm/damon.c | 149 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 198 insertions(+)
include/linux/damon.h +49 -0
@@ -55,6 +55,51 @@ struct damon_task {struct list_head list; }; +/** +* enum damos_action - Represents an action of a Data Access Monitoring-based +* Operation Scheme. +* +* @DAMOS_WILLNEED: Call ``madvise()`` for the region with MADV_WILLNEED. +* @DAMOS_COLD: Call ``madvise()`` for the region with MADV_COLD. +* @DAMOS_PAGEOUT: Call ``madvise()`` for the region with MADV_PAGEOUT. +* @DAMOS_HUGEPAGE: Call ``madvise()`` for the region with MADV_HUGEPAGE. +* @DAMOS_NOHUGEPAGE: Call ``madvise()`` for the region with MADV_NOHUGEPAGE. +* @DAMOS_ACTION_LEN: Number of supported actions. +*/ +enum damos_action { +DAMOS_WILLNEED , +DAMOS_COLD , +DAMOS_PAGEOUT , +DAMOS_HUGEPAGE , +DAMOS_NOHUGEPAGE , +DAMOS_ACTION_LEN , +}; + +/** +* struct damos - Represents a Data Access Monitoring-based Operation Scheme. +* @min_sz_region: Minimum size of target regions. +* @max_sz_region: Maximum size of target regions. +* @min_nr_accesses: Minimum ``->nr_accesses`` of target regions. +* @max_nr_accesses: Maximum ``->nr_accesses`` of target regions. +* @min_age_region: Minimum age of target regions. +* @max_age_region: Maximum age of target regions. +* @action: &damo_action to be applied to the target regions. +* @list: List head for siblings. +* +* For each aggregation interval, DAMON applies @action to monitoring target +* regions fit in the condition and updates the statistics. +*/ +struct damos { +unsigned int min_sz_region; +unsigned int max_sz_region; +unsigned int min_nr_accesses; +unsigned int max_nr_accesses; +unsigned int min_age_region; +unsigned int max_age_region; +enum damos_action action; +struct list_head list; +}; +/** * struct damon_ctx - Represents a context for each monitoring. This is the * main interface that allows users to set the attributes and get the results
@@ -98,6 +143,7 @@ struct damon_task {* @kdamond_lock. Accesses to other fields must be protected by themselves. * * @tasks_list: Head of monitring target tasks (&damon_task) list. +* @schemes_list: Head of schemes (&damos) list. * * @sample_cb: Called for each sampling interval. * @aggregate_cb: Called for each aggregation interval.
@@ -128,6 +174,7 @@ struct damon_ctx {struct mutex kdamond_lock;struct list_head tasks_list;/* 'damon_task' objects */ +struct list_head schemes_list;/* 'damos' objects */ /* callbacks */ void (*sample_cb)(struct damon_ctx *context);
@@ -138,6 +185,8 @@ int damon_set_pids(struct damon_ctx *ctx, int *pids, ssize_t nr_pids);int damon_set_attrs (struct damon_ctx *ctx,unsigned long sample_int,unsigned long aggr_int,unsigned long regions_update_int,unsigned long min_nr_reg,unsigned long max_nr_reg); +int damon_set_schemes (struct damon_ctx *ctx, +struct damos **schemes,ssize_t nr_schemes);int damon_set_recording (struct damon_ctx *ctx,unsigned int rbuf_len,char *rfile_path);int damon_start (struct damon_ctx *ctx);
mm/damon.c +149 -0
191 lines not on this page · raw message
Signature · 1 line
2.17.1
RFC v9 4/8 mm/damon/schemes: Implement a debugfs interface
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit implements a debugfs interface for the data access monitoring oriented memory management schemes. It is supposed to be used by administrators and/or privileged user space programs. Users can read and update the rules using ``<debugfs>/damon/schemes`` file. The format is::
<min/max size> <min/max access frequency> <min/max age> <action>
--- mm/damon.c | 176 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 174 insertions(+), 2 deletions(-)
mm/damon.c +174 -2
@@ -173,6 +173,29 @@ static void damon_destroy_task(struct damon_task *t)damon_free_task (t); } +static struct damos *damon_new_scheme ( +unsigned int min_sz_region,unsigned int max_sz_region, +unsigned int min_nr_accesses,unsigned int max_nr_accesses, +unsigned int min_age_region,unsigned int max_age_region, +enum damos_action action) +{ +struct damos *scheme; + + scheme =kmalloc (sizeof (*scheme),GFP_KERNEL ); +if (!scheme) +return NULL ; + scheme->min_sz_region = min_sz_region; + scheme->max_sz_region = max_sz_region; + scheme->min_nr_accesses = min_nr_accesses; + scheme->max_nr_accesses = max_nr_accesses; + scheme->min_age_region = min_age_region; + scheme->max_age_region = max_age_region; + scheme->action = action; +INIT_LIST_HEAD (&scheme->list); + +return scheme; +} +static void damon_add_scheme (struct damon_ctx *ctx,struct damos *s) {list_add_tail (&s->list, &ctx->schemes_list);
@@ -1354,6 +1377,149 @@ static ssize_t debugfs_monitor_on_write(struct file *file,return ret; } +static ssize_t sprint_schemes (struct damon_ctx *c,char *buf,ssize_t len) +{ +struct damos *s; +int written =0 ; +int rc; + +damon_for_each_scheme (s, c) { + rc =snprintf (&buf[written], len - written, +"%u %u %u %u %u %u %d\n" , + s->min_sz_region, s->max_sz_region, + s->min_nr_accesses, s->max_nr_accesses, + s->min_age_region, s->max_age_region, + s->action); +if (!rc) +return -ENOMEM ; + + written += rc; + } +return written; +} + +static ssize_t debugfs_schemes_read (struct file *file,char __user *buf, +size_t count,loff_t *ppos) +{ +struct damon_ctx *ctx = &damon_user_ctx; +char *kbuf; +ssize_t len; + + kbuf =kmalloc (count,GFP_KERNEL ); +if (!kbuf) +return -ENOMEM ; + +mutex_lock (&ctx->kdamond_lock); + len =sprint_schemes (ctx, kbuf, count); +mutex_unlock (&ctx->kdamond_lock); +if (len <0 ) + goto out; + len =simple_read_from_buffer (buf, count, ppos, kbuf, len); + +out: +kfree (kbuf); +return len; +} + +static void free_schemes_arr (struct damos **schemes,ssize_t nr_schemes) +{ +ssize_t i; + +for (i =0 ; i < nr_schemes; i++) +kfree (schemes[i]); +kfree (schemes); +} + +/* +* Converts a string into an array of struct damos pointers +* +* Returns an array of struct damos pointers that converted if the conversion +* success, or NULL otherwise. +*/ +static struct damos **str_to_schemes (const char *str,ssize_t len, +ssize_t *nr_schemes) +{ +struct damos *scheme, **schemes; +const int max_nr_schemes =256 ; +int pos =0 , parsed, ret; +unsigned int min_sz, max_sz, min_nr_a, max_nr_a, min_age, max_age; +unsigned int action; + + schemes =kmalloc_array (max_nr_schemes,sizeof (scheme), +GFP_KERNEL ); +if (!schemes) +return NULL ; + + *nr_schemes =0 ; +while (pos < len && *nr_schemes < max_nr_schemes) { + ret =sscanf (&str[pos],"%u %u %u %u %u %u %u%n" , + &min_sz, &max_sz, &min_nr_a, &max_nr_a, + &min_age, &max_age, &action, &parsed); +if (ret !=7 ) +break ; +if (action >=DAMOS_ACTION_LEN ) { +pr_err ("wrong action %d\n" , action); + goto fail; + } + + pos += parsed; + scheme =damon_new_scheme (min_sz, max_sz, min_nr_a, max_nr_a, + min_age, max_age, action); +if (!scheme) + goto fail; + + schemes[*nr_schemes] = scheme; + *nr_schemes +=1 ; + } +if (!*nr_schemes) + goto fail; +return schemes; +fail: +free_schemes_arr (schemes, *nr_schemes); +return NULL ; +} + +static ssize_t debugfs_schemes_write (struct file *file,const char __user *buf, +size_t count,loff_t *ppos) +{ +struct damon_ctx *ctx = &damon_user_ctx; +char *kbuf; +struct damos **schemes; +ssize_t nr_schemes =0 , ret; +int err; + +if (*ppos) +return -EINVAL ; + + kbuf =kmalloc (count,GFP_KERNEL ); +if (!kbuf) +return -ENOMEM ; + + ret =simple_write_to_buffer (kbuf, count, ppos, buf, count); +if (ret <0 ) + goto out; + + schemes =str_to_schemes (kbuf, ret, &nr_schemes); + +mutex_lock (&ctx->kdamond_lock); +if (ctx->kdamond) { + ret = -EBUSY ; + goto unlock_out; + } + + err =damon_set_schemes (ctx, schemes, nr_schemes); +if (err) + ret = err; +else + nr_schemes =0 ; +unlock_out: +mutex_unlock (&ctx->kdamond_lock); +free_schemes_arr (schemes, nr_schemes); +out: +kfree (kbuf); +return ret; +} +static ssize_t damon_sprint_pids (struct damon_ctx *ctx,char *buf,ssize_t len) {struct damon_task *t;
@@ -1585,6 +1751,12 @@ static const struct file_operations pids_fops = { .write = debugfs_pids_write, }; +static const struct file_operations schemes_fops = { + .owner =THIS_MODULE , + .read = debugfs_schemes_read, + .write = debugfs_schemes_write, +}; +static const struct file_operations record_fops = { .owner =THIS_MODULE , .read = debugfs_record_read,
@@ -1601,10 +1773,10 @@ static struct dentry *debugfs_root;static int __init damon_debugfs_init (void ) { -const char *const file_names[] = {"attrs" ,"record" , +const char *const file_names[] = {"attrs" ,"record" ,"schemes" ,"pids" ,"monitor_on" };const struct file_operations *fops[] = {&attrs_fops, &record_fops, - &pids_fops, &monitor_on_fops}; + &schemes_fops, &pids_fops, &monitor_on_fops};int i; debugfs_root =debugfs_create_dir ("damon" ,NULL );
Signature · 1 line
2.17.1
Re: [RFC v9 4/8] mm/damon/schemes: Implement a debugfs interface
Quoted 83 lines · On Tue, 26 May 2020 09:56:58 +0200 SeongJae Park <[email protected]> wrote:
From: SeongJae Park <[email protected]>
This commit implements a debugfs interface for the data access monitoring oriented memory management schemes. It is supposed to be used by administrators and/or privileged user space programs. Users can read and update the rules using ``<debugfs>/damon/schemes`` file. The format is::
<min/max size> <min/max access frequency> <min/max age> <action>
Signed-off-by SeongJae Park <[email protected]>--- mm/damon.c | 176 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 174 insertions(+), 2 deletions(-)mm/damon.c +61
-0@@ -173,6 +173,29 @@ static void damon_destroy_task(struct damon_task *t)damon_free_task (t); } + +/* +* Converts a string into an array of struct damos pointers +* +* Returns an array of struct damos pointers that converted if the conversion +* success, or NULL otherwise. +*/ +static struct damos **str_to_schemes (const char *str,ssize_t len, +ssize_t *nr_schemes) +{ +struct damos *scheme, **schemes; +const int max_nr_schemes =256 ; +int pos =0 , parsed, ret; +unsigned int min_sz, max_sz, min_nr_a, max_nr_a, min_age, max_age; +unsigned int action; + + schemes =kmalloc_array (max_nr_schemes,sizeof (scheme), +GFP_KERNEL ); +if (!schemes) +return NULL ; + + *nr_schemes =0 ; +while (pos < len && *nr_schemes < max_nr_schemes) { + ret =sscanf (&str[pos],"%u %u %u %u %u %u %u%n" , + &min_sz, &max_sz, &min_nr_a, &max_nr_a, + &min_age, &max_age, &action, &parsed); +if (ret !=7 ) +break ; +if (action >=DAMOS_ACTION_LEN ) { +pr_err ("wrong action %d\n" , action); + goto fail; + } + + pos += parsed; + scheme =damon_new_scheme (min_sz, max_sz, min_nr_a, max_nr_a, + min_age, max_age, action); +if (!scheme) + goto fail; + + schemes[*nr_schemes] = scheme; + *nr_schemes +=1 ; + } +if (!*nr_schemes) + goto fail; +return schemes; +fail: +free_schemes_arr (schemes, *nr_schemes); +return NULL ; +} + +static ssize_t debugfs_schemes_write (struct file *file,const char __user *buf, +size_t count,loff_t *ppos) +{ +struct damon_ctx *ctx = &damon_user_ctx; +char *kbuf; +struct damos **schemes; +ssize_t nr_schemes =0 , ret; +int err; + +if (*ppos) +return -EINVAL ;
mm/damon.c static void damon_destroy_task(struct damon_task *t) · line 1502
Quoted 10 lines
mm/damon.c +10
-0+ + kbuf =kmalloc (count,GFP_KERNEL ); +if (!kbuf) +return -ENOMEM ; + + ret =simple_write_to_buffer (kbuf, count, ppos, buf, count); +if (ret <0 ) + goto out; + + schemes =str_to_schemes (kbuf, ret, &nr_schemes);
In case of wrong input, 'str_to_schemes()' could return NULL with non-zero nr_schemes, but the case is not handled here. I will properly handle the case in the next spin.
Thanks,
SeongJae Park
Quoted 20 lines
mm/damon.c +20
-0+ +mutex_lock (&ctx->kdamond_lock); +if (ctx->kdamond) { + ret = -EBUSY ; + goto unlock_out; + } + + err =damon_set_schemes (ctx, schemes, nr_schemes); +if (err) + ret = err; +else + nr_schemes =0 ; +unlock_out: +mutex_unlock (&ctx->kdamond_lock); +free_schemes_arr (schemes, nr_schemes); +out: +kfree (kbuf); +return ret; +} +
RFC v9 5/8 mm/damon/schemes: Implement statistics feature
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
To tune the DAMON-based operation schemes, knowing how many and how large regions are affected by each of the schemes will be helful. Those stats could be used for not only the tuning, but also monitoring of the working set size and the number of regions, if the scheme does not change the program behavior too much.
For the reason, this commit implements the statistics for the schemes. The total number and size of the regions that each scheme is applied are exported to users via '->stat_count' and '->stat_sz' of 'struct damos'. Admins can also check the number by reading 'schemes' debugfs file. The last two integers now represents the stats. To allow collecting the stats without changing the program behavior, this commit also adds new scheme action, 'DAMOS_STAT'. Note that 'DAMOS_STAT' is not only making no memory operation actions, but also does not reset the age of regions.
--- include/linux/damon.h | 6 ++++++ mm/damon.c | 13 ++++++++++--- 2 files changed, 16 insertions(+), 3 deletions(-)
include/linux/damon.h +6 -0
@@ -64,6 +64,7 @@ struct damon_task {* @DAMOS_PAGEOUT: Call ``madvise()`` for the region with MADV_PAGEOUT. * @DAMOS_HUGEPAGE: Call ``madvise()`` for the region with MADV_HUGEPAGE. * @DAMOS_NOHUGEPAGE: Call ``madvise()`` for the region with MADV_NOHUGEPAGE. +* @DAMOS_STAT: Do nothing but count the stat. * @DAMOS_ACTION_LEN: Number of supported actions. */ enum damos_action {
@@ -72,6 +73,7 @@ enum damos_action {DAMOS_PAGEOUT ,DAMOS_HUGEPAGE ,DAMOS_NOHUGEPAGE , +DAMOS_STAT ,/* Do nothing but only record the stat */ DAMOS_ACTION_LEN, };
@@ -84,6 +86,8 @@ enum damos_action {* @min_age_region: Minimum age of target regions. * @max_age_region: Maximum age of target regions. * @action: &damo_action to be applied to the target regions. +* @stat_count: Total number of regions that this scheme is applied. +* @stat_sz: Total size of regions that this scheme is applied. * @list: List head for siblings. * * For each aggregation interval, DAMON applies @action to monitoring target
@@ -97,6 +101,8 @@ struct damos {unsigned int min_age_region;unsigned int max_age_region;enum damos_action action; +unsigned long stat_count; +unsigned long stat_sz;struct list_head list; };
mm/damon.c +10 -3
@@ -191,6 +191,8 @@ static struct damos *damon_new_scheme( scheme->min_age_region = min_age_region; scheme->max_age_region = max_age_region; scheme->action = action; + scheme->stat_count =0 ; + scheme->stat_sz =0 ;INIT_LIST_HEAD (&scheme->list);return scheme;
@@ -771,6 +773,8 @@ static int damos_do_action(struct damon_task *task, struct damon_region *r,case DAMOS_NOHUGEPAGE : madv_action =MADV_NOHUGEPAGE ;break ; +case DAMOS_STAT : +return 0 ;default :pr_warn ("Wrong action %d\n" , action);return -EINVAL ;
@@ -798,8 +802,11 @@ static void damon_do_apply_schemes(struct damon_ctx *c, struct damon_task *t, (s->max_age_region && s->max_age_region < r->age)) continue; + s->stat_count++; + s->stat_sz += sz;damos_do_action (t, r, s->action); - r->age =0 ; +if (s->action !=DAMOS_STAT ) + r->age =0 ; } }
@@ -1385,11 +1392,11 @@ static ssize_t sprint_schemes(struct damon_ctx *c, char *buf, ssize_t len)damon_for_each_scheme (s, c) { rc =snprintf (&buf[written], len - written, -"%u %u %u %u %u %u %d\n" , +"%u %u %u %u %u %u %d %lu %lu\n" , s->min_sz_region, s->max_sz_region, s->min_nr_accesses, s->max_nr_accesses, s->min_age_region, s->max_age_region, - s->action); + s->action, s->stat_count, s->stat_sz);if (!rc)return -ENOMEM ;
Signature · 1 line
2.17.1
RFC v9 6/8 mm/damon/selftests: Add 'schemes' debugfs tests
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit adds simple selftets for 'schemes' debugfs file of DAMON.
--- .../testing/selftests/damon/debugfs_attrs.sh | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+)
tools/testing/selftests/damon/debugfs_attrs.sh +29 -0
@@ -97,6 +97,35 @@ fi echo $ORIG_CONTENT > $file +# Test schemes file +file="$DBGFS/schemes" + +ORIG_CONTENT=$(cat $file) +echo "1 2 3 4 5 6 3" > $file +if [ $? -ne 0 ] +then + echo "$file write fail" + echo $ORIG_CONTENT > $file + exit 1 +fi + +echo "1 2 +3 4 5 6 3" > $file +if [ $? -eq 0 ] +then + echo "$file multi line write success (expected fail)" + echo $ORIG_CONTENT > $file + exit 1 +fi + +echo > $file +if [ $? -ne 0 ] +then + echo "$file empty string writing fail" + echo $ORIG_CONTENT > $file + exit 1 +fi + # Test pids file file="$DBGFS/pids"
Signature · 1 line
2.17.1
RFC v9 7/8 damon/tools: Support more human friendly 'schemes' control
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit implements 'schemes' subcommand of the damon userspace tool. It can be used to describe and apply the data access monitoring-based operation schemes in more human friendly fashion.
--- tools/damon/_convert_damos.py | 128 ++++++++++++++++++++++++++++++ tools/damon/_damon.py | 143 ++++++++++++++++++++++++++++++++++ tools/damon/damo | 7 ++ tools/damon/record.py | 135 +++----------------------------- tools/damon/schemes.py | 105 +++++++++++++++++++++++++ 5 files changed, 395 insertions(+), 123 deletions(-) create mode 100755 tools/damon/_convert_damos.py create mode 100644 tools/damon/_damon.py create mode 100644 tools/damon/schemes.py
tools/damon/_convert_damos.py new file +128 -0
@@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: GPL-2.0 + +""" +Change human readable data access monitoring-based operation schemes to the low +level input for the '<debugfs>/damon/schemes' file. Below is an example of the +schemes written in the human readable format: + + # format is: + # <min/max size> <min/max frequency (0-99)> <min/max age> <action> + # + # B/K/M/G/T for Bytes/KiB/MiB/GiB/TiB + # us/ms/s/m/h/d for micro-seconds/milli-seconds/seconds/minutes/hours/days + # 'null' means zero for size and age. + + # if a region keeps a high access frequency for more than 100ms, put the + # region on the head of the LRU list (call madvise() with MADV_WILLNEED). + null null 80 null 100ms 0s willneed + + # if a region keeps a low access frequency for more than 200ms and less + # than one hour, put the # region on the tail of the LRU list (call + # madvise() with MADV_COLD). + 0B 0B 10 20 200ms 1h cold + + # if a region keeps a very low access frequency for more than 1 minute, + # swap out the region immediately (call madvise() with MADV_PAGEOUT). + 0B null 0 10 60s 0s pageout + + # if a region of a size bigger than 2MiB keeps a very high access frequency + # for more than 100ms, let the region to use huge pages (call madvise() + # with MADV_HUGEPAGE). + 2M null 90 99 100ms 0s hugepage + + # If a regions of a size bigger than 2MiB keeps small access frequency for + # more than 100ms, avoid the region using huge pages (call madvise() with + # MADV_NOHUGEPAGE). + 2M null 0 25 100ms 0s nohugepage +""" + +import argparse + +unit_to_bytes = {'B': 1, 'K': 1024, 'M': 1024 * 1024, 'G': 1024 * 1024 * 1024, + 'T': 1024 * 1024 * 1024 * 1024} + +def text_to_bytes(txt): + if txt == 'null': + return 0 + unit = txt[-1] + number = int(txt[:-1]) + return number * unit_to_bytes[unit] + +unit_to_usecs = {'us': 1, 'ms': 1000, 's': 1000 * 1000, 'm': 60 * 1000 * 1000, + 'h': 60 * 60 * 1000 * 1000, 'd': 24 * 60 * 60 * 1000 * 1000} + +def text_to_us(txt): + if txt == 'null': + return 0 + unit = txt[-2:] + if unit in ['us', 'ms']: + number = int(txt[:-2]) + else: + unit = txt[-1] + number = int(txt[:-1]) + return number * unit_to_usecs[unit] + +damos_action_to_int = {'DAMOS_WILLNEED': 0, 'DAMOS_COLD': 1, + 'DAMOS_PAGEOUT': 2, 'DAMOS_HUGEPAGE': 3, 'DAMOS_NOHUGEPAGE': 4, + 'DAMOS_STAT': 5} + +def text_to_damos_action(txt): + return damos_action_to_int['DAMOS_' + txt.upper()] + +def text_to_nr_accesses(txt, max_nr_accesses): + if txt == 'null': + return 0 + return int(int(txt) * max_nr_accesses / 100) + +def debugfs_scheme(line, sample_interval, aggr_interval): + fields = line.split() + if len(fields) != 7: + print('wrong input line: %s' % line) + exit(1) + + limit_nr_accesses = aggr_interval / sample_interval + try: + min_sz = text_to_bytes(fields[0]) + max_sz = text_to_bytes(fields[1]) + min_nr_accesses = text_to_nr_accesses(fields[2], limit_nr_accesses) + max_nr_accesses = text_to_nr_accesses(fields[3], limit_nr_accesses) + min_age = text_to_us(fields[4]) / aggr_interval + max_age = text_to_us(fields[5]) / aggr_interval + action = text_to_damos_action(fields[6]) + except: + print('wrong input field') + raise + return '%d\t%d\t%d\t%d\t%d\t%d\t%d' % (min_sz, max_sz, min_nr_accesses, + max_nr_accesses, min_age, max_age, action) + +def convert(schemes_file, sample_interval, aggr_interval): + lines = [] + with open(schemes_file, 'r') as f: + for line in f: + if line.startswith('#'): + continue + line = line.strip() + if line == '': + continue + lines.append(debugfs_scheme(line, sample_interval, aggr_interval)) + return '\n'.join(lines) + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('input', metavar='<file>', + help='input file describing the schemes') + parser.add_argument('-s', '--sample', metavar='<interval>', type=int, + default=5000, help='sampling interval (us)') + parser.add_argument('-a', '--aggr', metavar='<interval>', type=int, + default=100000, help='aggregation interval (us)') + args = parser.parse_args() + + schemes_file = args.input + sample_interval = args.sample + aggr_interval = args.aggr + + print(convert(schemes_file, sample_interval, aggr_interval)) + +if __name__ == '__main__': + main()
tools/damon/_damon.py new file +143 -0
143 lines not on this page · raw message
tools/damon/damo +7 -0
@@ -5,6 +5,7 @@ import argparse import record import report +import schemes class SubCmdHelpFormatter(argparse.RawDescriptionHelpFormatter): def _format_action(self, action):
@@ -25,6 +26,10 @@ parser_record = subparser.add_parser('record', help='record data accesses of the given target processes') record.set_argparser(parser_record) +parser_schemes = subparser.add_parser('schemes', + help='apply operation schemes to the given target process') +schemes.set_argparser(parser_schemes) + parser_report = subparser.add_parser('report', help='report the recorded data accesses in the specified form') report.set_argparser(parser_report)
@@ -33,5 +38,7 @@ args = parser.parse_args() if args.command == 'record': record.main(args) +elif args.command == 'schemes': + schemes.main(args) elif args.command == 'report': report.main(args)
tools/damon/record.py +12 -123
197 lines not on this page · raw message
tools/damon/schemes.py new file +105 -0
105 lines not on this page · raw message
Signature · 1 line
2.17.1
RFC v9 8/8 Documentation/admin-guide/mm: Document DAMON-based operation schemes
In reply to SeongJae ParkFrom: SeongJae Park <[email protected]>
This commit documents DAMON-based operation schemes in the DAMON document.
--- Documentation/admin-guide/mm/damon/guide.rst | 35 ++++++ Documentation/admin-guide/mm/damon/usage.rst | 126 +++++++++++++++++-- 2 files changed, 151 insertions(+), 10 deletions(-)
Documentation/admin-guide/mm/damon/guide.rst +35 -0
@@ -55,6 +55,11 @@ heats``. If it shows a simple pattern consists of a small number of memory regions having high contrast of access temperature, you could consider `Manual Program Optimization`_. +If the access pattern is very frequently changing so that you cannot figure out +what is the performance important region using your human eye, `Automated +DAMON-based Memory Operations`_ might help the case owing to its machine-level +microscope view. + You don't need to take only one approach among the above plans, but you could use multiple of the above approaches to maximize the benefit. If you still want to absorb more benefits, you should develop `Personalized DAMON
@@ -158,6 +163,36 @@ object is the hot object. The chronological changes of working set size. +Automated DAMON-based Memory Operations +--------------------------------------- + +Though `Manual Program Optimization` works well in many cases and DAMON can +help it, modifying the source code is not a good option in many cases. First +of all, the source code could be too old or unavailable. And, many workloads +will have complex data access patterns that even hard to distinguish hot memory +objects and cold memory objects with the human eye. Finding the mapping from +the visualized access pattern to the source code and injecting the hinting +system calls inside the code will also be quite challenging. + +By using DAMON-based operation schemes (DAMOS) via ``damo schemes``, you will +be able to easily optimize your workload in such a case. Our example schemes +called 'efficient THP' and 'proactive reclamation' achieved significant speedup +and memory space saves against 25 realistic workloads [2]_, [3]_. + +That said, note that you need careful tune of the schemes (e.g., target region +size and age) and monitoring attributes for the successful use of this +approach. Because the optimal values of the parameters will be dependent on +each system and workload, misconfiguring the parameters could result in worse +memory management. + +For the tuning, you could measure the performance metrics such as IPC, TLB +misses, and swap in/out events and adjusts the parameters based on their +changes. The total number and the total size of the regions that each scheme +is applied, which are provided via the debugfs interface and the programming +interface can also be useful. Writing a program automating this optimal +parameter could be an option. + + Personalized DAMON Application ------------------------------
Documentation/admin-guide/mm/damon/usage.rst +116 -10
144 lines not on this page · raw message
Signature · 1 line
2.17.1