mm/damon: introduce DAMOS failed region quota charge ratio
Subsystems (5)
SeongJae Park
maintainercover mm/damon: introduce DAMOS failed region quota charge ratio
TL; DR: Let users set different DAMOS quota charge ratios for DAMOS action failed regions, for deterministic and consistent DAMOS action progress.
Common Reports: Unexpectedly Slow DAMOS
=======================================
One common issue report that we get from DAMON users is that DAMOS action applying progress speed is sometimes much slower than expected. And one common root cause is that the DAMOS quota is exceeded by the action applying failed memory regions.
For example, a group of users tried to run DAMOS-based proactive memory reclamation (DAMON_RECLAIM) with 100 MiB per second DAMOS quota. They ran it on a system having no active workload which means all memory of the system is cold. The expectation was that the system will show 100 MiB per second reclamation until (nearly) all memory is reclaimed. But what they found is that the speed is quite inconsistent and sometimes it becomes very slower than the expectation, sometimes even no reclamation at all for about tens of seconds. The upper limit of the speed (100 MiB per second) was being kept as expected, though.
By monitoring the qt_exceeds (number of DAMOS quota exceed events) DAMOS stat, we found DAMOS quota is always exceeded when the speed is slow. By monitoring sz_tried and sz_applied (the total amount of DAMOS action tried memory and succeeded memory) DAMOS stats together, we found the reclamation attempts nearly always failed when the speed is slow.
DAMOS quota charges DAMOS action tried regions regardless of the successfulness of the try. Hence in the example reported case, there was unreclaimable memory spread around the system memory. Sometimes nearly 100 MiB of memory that DAMOS tried to reclaim in the given quota interval was reclaimable, and therefore showed nearly 100 MiB per second speed. Sometimes nearly 99 MiB of memory that DAMOS was trying to reclaim in the given quota interval was unreclaimable, and therefore showing only about 1 MiB per second reclaim speed.
We explained it is an expected behavior of the feature rather than a bug, as DAMOS quota is there for only the upper-limit of the speed. The users agreed and later reported a huge win from the adoption of DAMON_RECLAIM on their products.
It is Not a Bug but a Feature; But...
=====================================
So nothing is broken. DAMOS quota is working as intended, as the upper limit of the speed. It also provides its behavior observability via DAMOS stat. In the real world production environment that runs long term active workloads and matters stability, the speed sometimes being slow is not a real problem.
But, the non-deterministic behavior is sometimes annoying, especially in lab environments. Even in a realistic production environment, when there is a huge amount of DAMOS action unapplicable memory, the speed could be problematically slow. Let's suppose a virtual machines provider that setup 99% of the host memory as hugetlb pages that cannot be reclaimed, to give it to virtual machines. Also, when aim-oriented DAMOS auto-tuning is applied, this could also make the internal feedback loop confused.
The intention of the current behavior was that trying DAMOS action to regions would anyway impose some overhead, and therefore somehow be charged. But in the real world, the overhead for failed action is much lighter than successful action. Charging those at the same ratio may be unfair, or at least suboptimum in some environments.
DAMOS Action Failed Region Quota Charge Ratio
=============================================
Let users set the charge ratio for the action-failed memory, for more optimal and deterministic use of DAMOS. It allows users to specify the numerator and the denominator of the ratio for flexible setup. For example, let's suppose the numerator and the denominator are set to 1 and 4,096, respectively. The ratio is 1 / 4,096. A DAMOS scheme action is applied to 5 GiB memory. For 1 GiB of the memory, the action is succeeded. For the rest (4 GiB), the action is failed. Then, only 1 GiB and 1 MiB quota is charged.
The optimal charge ratio will depend on the use case and system/workload. I'd recommend starting from setting the nominator as 1 and the denominator as PAGE_SIZE and tune based on the results, because many DAMOS actions are applied at page level.
Tests
=====
I tested this feature in the steps below.
1. Allocate 50% of system memory and mlock() it using a test program.
2. Fill up the page cache to exhaust nearly all free memory.
3. Start DAMON-based proactive reclamation with 100 MiB/second DAMOS hard-quota. Auto-tune the DAMOS soft-quota under the hard-quota for achieving 40% free memory of the system with 'temporal' tuner.
For step 1, I run a simple C program that is written by Gemini. It is quite straightforward, so I'm not sharing the code here.
For step 2, I use dd command like below:
dd if=/dev/zero of=foo bs=1M count=$50_percent_of_system_memory
For step 3, I use the latest version of DAMON user-space tool (damo) like below.
sudo damo start --damos_action pageout \
` # Do the pageout only up to 100 MiB per second ` \
--damos_quota_space 100M --damos_quota_interval 1s \
` # Auto-tune the quota below the hard quota aiming` \
` # 40% free memory of the node 0 ` \
` # (entire node of the test system)` \
--damos_quota_goal node_mem_free_bp 40% 0 \
` # use temporal tuner, which is easy to understnd ` \
--damos_quota_goal_tuner temporalAs expected, the progress of the reclamation is not consistent, because the quota is exceeded for the failed reclamation of the unreclaimable memory.
I do this again, but with the failed region charge ratio feature. For this, the above 'damo' command is used, after appending command line option for setup of the charge ratio like below. Note that the option was added to 'damo' after v3.1.9.
sudo ./damo start --damos_action pageout \
[...]
` # quota-charge only 1/4096 for pageout-failed regions ` \
--damos_quota_fail_charge_ratio 1 4096The progress of the reclamation was nearly 100 MiB per second until the goal was achieved, meeting the expectation.
Patches Sequence
================
Patch 1 implements the feature and exposes it via DAMON core API. Patch 2 implements DAMON sysfs ABI for the feature. Three following patches (3-5) document the feature and ABI on design, usage, and ABI documents, respectively. Four patches for testing of the new feature follow. Patch 6 implements a kunit test for the feature. Patches 7 and 8 extend DAMON selftest helpers for DAMON sysfs control and internal state dumping for adding a new selftest for the feature. Patch 9 extends existing DAMON sysfs interface selftest to test the new feature using the extended helper scripts.
SeongJae Park (9):
mm/damon/core: introduce failed region quota charge ratio mm/damon/sysfs-schemes: implement fail_charge_{num,denom} files Docs/mm/damon/design: document fail_charge_{num,denom} Docs/admin-guide/mm/damon/usage: document fail_charge_{num,denom}
files
Docs/ABI/damon: document fail_charge_{num,denom} mm/damon/tests/core-kunit: test fail_charge_{num,denom} committing selftets/damon/_damon_sysfs: support failed region quota charge ratio selftests/damon/drgn_dump_damon_status: support failed region quota
charge ratio
selftets/damon/sysfs.py: test failed region quota charge ratio
.../ABI/testing/sysfs-kernel-mm-damon | 12 +++++ Documentation/admin-guide/mm/damon/usage.rst | 18 +++++-- Documentation/mm/damon/design.rst | 21 ++++++++ include/linux/damon.h | 9 ++++ mm/damon/core.c | 9 +++- mm/damon/sysfs-schemes.c | 54 +++++++++++++++++++ mm/damon/tests/core-kunit.h | 6 +++ tools/testing/selftests/damon/_damon_sysfs.py | 21 +++++++- .../selftests/damon/drgn_dump_damon_status.py | 2 + tools/testing/selftests/damon/sysfs.py | 6 +++ 10 files changed, 151 insertions(+), 7 deletions(-)
base-commit: 9e634d6813be2e3d1cb023a0b83619fd2bcdd13b
Signature · 1 line
2.47.3
SeongJae Park
maintainerRFC PATCH 1/9 mm/damon/core: introduce failed region quota charge ratio
DAMOS quota is charged to all DAMOS action application attempted memory, regardless of how much of the memory the action was successful and failed. This makes understanding quota behavior without DAMOS stat but only with end level metrics (e.g., increased amount of free memory for DAMOS_PAGEOUT action) difficult. Also, charging action-failed memory same as action-successful memory is somewhat unfair, as successful action application will induce more overhead in most cases.
Introduce DAMON core API for setting the charge ratio for such action-failed memory. It allows API callers to specify the ratio in a flexible way, by setting the numerator and the denominator.
--- include/linux/damon.h | 9 +++++++++ mm/damon/core.c | 9 ++++++++- 2 files changed, 17 insertions(+), 1 deletion(-)
include/linux/damon.h +9 -0
@@ -233,6 +233,8 @@ enum damos_quota_goal_tuner {* @goals: Head of quota tuning goals (&damos_quota_goal) list. * @goal_tuner: Goal-based @esz tuning algorithm to use. * @esz: Effective size quota in bytes. +* @fail_charge_num: Failed regions charge rate numerator. +* @fail_charge_denom: Failed regions charge rate denominator. * * @weight_sz: Weight of the region's size for prioritization. * @weight_nr_accesses: Weight of the region's nr_accesses for prioritization.
@@ -262,6 +264,10 @@ enum damos_quota_goal_tuner {* * The resulting effective size quota in bytes is set to @esz. * +* For DAMOS action applying failed amount of regions, charging those same to +* those that the action has successfully applied may be unfair. For the +* reason, 'the size * @fail_charge_num / @fail_charge_denom' is charged. +* * For selecting regions within the quota, DAMON prioritizes current scheme's * target memory regions using the &struct damon_operations->get_scheme_score. * You could customize the prioritization logic by setting &weight_sz,
@@ -276,6 +282,9 @@ struct damos_quota {enum damos_quota_goal_tuner goal_tuner;unsigned long esz; +unsigned int fail_charge_num; +unsigned int fail_charge_denom; +unsigned int weight_sz;unsigned int weight_nr_accesses;unsigned int weight_age;
mm/damon/core.c +8 -1
@@ -918,6 +918,8 @@ static int damos_commit_quota(struct damos_quota *dst, struct damos_quota *src)if (err)return err; dst->goal_tuner = src->goal_tuner; + dst->fail_charge_num = src->fail_charge_num; + dst->fail_charge_denom = src->fail_charge_denom; dst->weight_sz = src->weight_sz; dst->weight_nr_accesses = src->weight_nr_accesses; dst->weight_age = src->weight_age;
@@ -2098,7 +2100,12 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,ktime_get_coarse_ts64 (&end); quota->total_charged_ns +=timespec64_to_ns (&end) -timespec64_to_ns (&begin); - quota->charged_sz += sz; +if (quota->fail_charge_denom) + quota->charged_sz += sz_applied + + (sz - sz_applied) * quota->fail_charge_num / + quota->fail_charge_denom; +else + quota->charged_sz += sz;if (damos_quota_is_set (quota) && quota->charged_sz >= quota->esz) { quota->charge_target_from = t;
Signature · 1 line
2.47.3
SeongJae Park
maintainerRe: (sashiko review) [RFC PATCH 1/9] mm/damon/core: introduce failed region quota charge ratio
sashiko found an issue that better to be fixed. I will fix it in the next revision.
Forwarding sashiko review in a reply format with my inline comments below, for details of my view and doing discussions via mails if needed.
Quoted 26 lines
# review url: https://sashiko.dev/#/patchset/[email protected] # start of sashiko.dev inline review commit a0c4b65226ecf5534b53ebac64430db94a861d2c Author: SeongJae Park <[email protected]>
mm/damon/core: introduce failed region quota charge ratioThis commit introduces a mechanism to specify how much of a DAMOS action's failed memory should be charged to the quota. It adds numerator and denominator parameters to allow flexible charge ratio configuration.
Quoted 4 lines
include/linux/damon.h +0
-0[ ... ]
include/linux/damon.h struct damos_quota { · line 286
Quoted 6 lines
include/linux/damon.h +2
-0@@ -276,6 +282,9 @@ struct damos_quota {enum damos_quota_goal_tuner goal_tuner;unsigned long esz; +unsigned int fail_charge_num; +unsigned int fail_charge_denom;Is there a guarantee that
fail_charge_numis less than or equal tofail_charge_denom?
Quoted 6 lines
If
fail_charge_numis larger, the added charge will be greater than sz. When a region is split to exactly fit the remaining quota, could this makequota->charged_szstrictly greater thanquota->esz?If so, would the remaining quota calculation in the next iteration underflow and lead to corrupting the
damon_regionboundaries when splitting?
No. Existing charged_sz vs esz comparison code allows charged_sz be larger than esz, using '>=' operator. And when the next charge window starts, quota->charged_sz is reset to zero. So I show no problem here.
Quoted 24 lines
Quoted 9 lines
include/linux/damon.h +1
-0+unsigned int weight_sz;unsigned int weight_nr_accesses;unsigned int weight_age;mm/damon/core.c +0
-0[ ... ]
mm/damon/core.c static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t, · line 2105
Quoted 9 lines
mm/damon/core.c +4
-1@@ -2097,7 +2099,12 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t,ktime_get_coarse_ts64 (&end); quota->total_charged_ns +=timespec64_to_ns (&end) -timespec64_to_ns (&begin); - quota->charged_sz += sz; +if (quota->fail_charge_denom) + quota->charged_sz += sz_applied + + (sz - sz_applied) * quota->fail_charge_num / + quota->fail_charge_denom;If memory management operations backing
apply_scheme(likedamon_pa_pageout) process whole folios, cansz_appliedbe strictly greater than the region's size sz (for example, when a 4KB region overlaps with a 2MB THP)?
Quoted 2 lines
Does this cause the unsigned subtraction (sz -
sz_applied) to underflow into a very large positive value, exhausting the quota prematurely?
Good point. The premature quota exhaustion should not be a critical issue, but better to be avoided. I will fix this in the next revision.
Quoted 7 lines
Could the multiplication (sz -
sz_applied) *quota->fail_charge_numoverflow before division?On 32-bit architectures, or with a large
fail_charge_num, could this wrap around and result in a much smaller charge than expected, allowing the scheme to bypass the quota limits?
I will use mult_frac() to avoid unnecessary overflow.
Quoted 9 lines
What happens if an action fails, and
fail_charge_numis set to 0?Does
quota->charged_szremain unchanged while the region is split to fit the remaining quota?Since the remaining quota stays the same, could this cause the subsequent loop iterations to continuously split the remainder of the region into identical small chunks, allocating a massive number of
damon_regionstructures?
That could happen, if that's what the user intend to. That's no problem.
Quoted 10 lines
mm/damon/core.c static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t, · line 2111
Quoted 6 lines
mm/damon/core.c +2
-0+else + quota->charged_sz += sz;if (damos_quota_is_set (quota) && quota->charged_sz >= quota->esz) { quota->charge_target_from = t;# end of sashiko.dev inline review # review url: https://sashiko.dev/#/patchset/[email protected]
Thanks,
SJ
# hkml [1] generated a draft of this mail. You can regenerate # this using below command: # # hkml patch sashiko_dev --for_forwarding \ # [email protected] # # [1] https://github.com/sjp38/hackermail
SeongJae Park
maintainerRFC PATCH 2/9 mm/damon/sysfs-schemes: implement fail_charge_{num,denom} files
In reply to SeongJae ParkImplement the user-space ABI for the DAMOS action failed region quota-charge ratio setup. For this, add two new sysfs files under the DAMON sysfs interface for DAMOS quotas. Names of the files are fail_charge_num and fail_charge_denom, and work for reading and setting the numerator and denominator of the failed regions charge ratio.
--- mm/damon/sysfs-schemes.c | 54 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+)
mm/damon/sysfs-schemes.c +54 -0
@@ -1489,6 +1489,8 @@ struct damon_sysfs_quotas {unsigned long reset_interval_ms;unsigned long effective_sz;/* Effective size quota in bytes */ enum damos_quota_goal_tuner goal_tuner; +unsigned int fail_charge_num; +unsigned int fail_charge_denom; };static struct damon_sysfs_quotas *damon_sysfs_quotas_alloc (void )
@@ -1663,6 +1665,48 @@ static ssize_t goal_tuner_store(struct kobject *kobj,return -EINVAL ; } +static ssize_t fail_charge_num_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +struct damon_sysfs_quotas *quotas =container_of (kobj, + struct damon_sysfs_quotas, kobj); + +return sysfs_emit (buf,"%u\n" , quotas->fail_charge_num); +} + +static ssize_t fail_charge_num_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_quotas *quotas =container_of (kobj, + struct damon_sysfs_quotas, kobj); +int err =kstrtouint (buf,0 , "as->fail_charge_num); + +if (err) +return -EINVAL ; +return count; +} + +static ssize_t fail_charge_denom_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +struct damon_sysfs_quotas *quotas =container_of (kobj, + struct damon_sysfs_quotas, kobj); + +return sysfs_emit (buf,"%u\n" , quotas->fail_charge_denom); +} + +static ssize_t fail_charge_denom_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_quotas *quotas =container_of (kobj, + struct damon_sysfs_quotas, kobj); +int err =kstrtouint (buf,0 , "as->fail_charge_denom); + +if (err) +return -EINVAL ; +return count; +} +static void damon_sysfs_quotas_release (struct kobject *kobj) {kfree (container_of(kobj ,struct damon_sysfs_quotas ,kobj ));
@@ -1683,12 +1727,20 @@ static struct kobj_attribute damon_sysfs_quotas_effective_bytes_attr =static struct kobj_attribute damon_sysfs_quotas_goal_tuner_attr =__ATTR_RW_MODE (goal_tuner,0600 ); +static struct kobj_attribute damon_sysfs_quotas_fail_charge_num_attr = +__ATTR_RW_MODE (fail_charge_num,0600 ); + +static struct kobj_attribute damon_sysfs_quotas_fail_charge_denom_attr = +__ATTR_RW_MODE (fail_charge_denom,0600 ); +static struct attribute *damon_sysfs_quotas_attrs[] = { &damon_sysfs_quotas_ms_attr.attr, &damon_sysfs_quotas_sz_attr.attr, &damon_sysfs_quotas_reset_interval_ms_attr.attr, &damon_sysfs_quotas_effective_bytes_attr.attr, &damon_sysfs_quotas_goal_tuner_attr.attr, + &damon_sysfs_quotas_fail_charge_num_attr.attr, + &damon_sysfs_quotas_fail_charge_denom_attr.attr,NULL , };ATTRIBUTE_GROUPS (damon_sysfs_quotas);
@@ -2776,6 +2828,8 @@ static struct damos *damon_sysfs_mk_scheme( .weight_nr_accesses = sysfs_weights->nr_accesses, .weight_age = sysfs_weights->age, .goal_tuner = sysfs_quotas->goal_tuner, + .fail_charge_num = sysfs_quotas->fail_charge_num, + .fail_charge_denom = sysfs_quotas->fail_charge_denom, };struct damos_watermarks wmarks = { .metric = sysfs_wmarks->metric,
Signature · 1 line
2.47.3
SeongJae Park
maintainerRe: (sashiko review) [RFC PATCH 2/9] mm/damon/sysfs-schemes: implement fail_charge_{num,denom} files
sashiko found no real issue for this patch.
Forwarding sashiko review in a reply format with my inline comments below, for details of my view and doing discussions via mails if needed.
Quoted 53 lines
# review url: https://sashiko.dev/#/patchset/[email protected] # start of sashiko.dev inline review commit ee565644ac37e8bfceab5e62746d85906fb91b43 Author: SeongJae Park <[email protected]>
mm/damon/sysfs-schemes: implement fail_charge_{num,denom} filesThis commit implements the user-space ABI for the DAMOS action failed region quota-charge ratio setup. It adds two new sysfs files under the DAMON sysfs interface for DAMOS quotas,
fail_charge_numandfail_charge_denom, which allow reading and setting the numerator and denominator of the failed regions charge ratio.Quoted 4 lines
mm/damon/sysfs-schemes.c +0
-0[ ... ]
Quoted 12 lines
mm/damon/sysfs-schemes.c +8
-0@@ -1663,6 +1665,48 @@ static ssize_t goal_tuner_store(struct kobject *kobj,return -EINVAL ; } +static ssize_t fail_charge_num_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +struct damon_sysfs_quotas *quotas =container_of (kobj, + struct damon_sysfs_quotas, kobj); + +return sysfs_emit (buf,"%u\n" , quotas->fail_charge_num); +}mm/damon/sysfs-schemes.c static ssize_t goal_tuner_store(struct kobject *kobj, · line 1685
Quoted 10 lines
mm/damon/sysfs-schemes.c +10
-0+ +static ssize_t fail_charge_num_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_quotas *quotas =container_of (kobj, + struct damon_sysfs_quotas, kobj); +int err =kstrtouint (buf,0 , "as->fail_charge_num); + +if (err) +return -EINVAL ;Could this lack of upper bounds checking lead to an integer overflow when the scheme is applied in the DAMON core?
If a user provides a large value for
fail_charge_numup toUINT_MAX, could the charge calculation indamos_apply_scheme():(sz -
sz_applied) *quota->fail_charge_num/quota->fail_charge_denomoverflow the unsigned long value?
Quoted 8 lines
For example, on a 32-bit system, an unapplied region of just 5 MB multiplied by a user-supplied numerator of 1,000 yields over 5 billion, which exceeds the 32-bit maximum limit. On a 64-bit system, a 10 GB region multiplied by 4,000,000,000 would similarly overflow.
When this overflow occurs, does the charged size wrap around to a very small value, causing the DAMOS action quota to be drastically undercharged and bypassing the user-defined limits?
That can happen, but shouldn't cause a real problem. Meanwhile, adding such overflow check would make code unnecessarily complicated. I will keep this as is. If it turns out this causes a real problem, we can consider making this better documented or updating the code later, after the report is really made.
Thanks,
SJ
Quoted 9 lines
Quoted 3 lines
mm/damon/sysfs-schemes.c +2
-0+return count; +}[ ... ]
# end of sashiko.dev inline review # review url: https://sashiko.dev/#/patchset/[email protected]
# hkml [1] generated a draft of this mail. You can regenerate # this using below command: # # hkml patch sashiko_dev --for_forwarding \ # [email protected] # # [1] https://github.com/sjp38/hackermail
SeongJae Park
maintainerRFC PATCH 3/9 Docs/mm/damon/design: document fail_charge_{num,denom}
In reply to SeongJae ParkUpdate DAMON design document for the DAMOS action failed region quota charge ratio.
--- Documentation/mm/damon/design.rst | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
Documentation/mm/damon/design.rst +21 -0
@@ -572,6 +572,27 @@ interface <sysfs_interface>`, refer to :ref:`weights <sysfs_quotas>` part of the documentation. +.. _damon_design_damos_quotas_failed_memory_charging_ratio: + +Action-failed Memory Charging Ratio +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +DAMOS action to a given region can fail for sub subsets of the memory of the +region. For example, if the action is ``pageout`` and the region has some +unreclaimable pages, applying the action to the pages will fail. The amount of +system resource that is taken for such failed action applications is usually +different from that for successful action applications. For such cases, users +can set different charging ratio for such failed memory. The ratio can be +specified using ``fail_charge_num`` and ``fail_charge_denom`` parameters. The +two parameters represent the numerator and denominator of the ratio. + +For example, let's suppose a DAMOS action is applied to a region of 1 GiB size. +The action is successfully applied to only 700 MiB of the region. +``fail_charge_num`` and ``fail_charge_denom`` are set to ``1`` and ``1024``, +respectively. Then only 700 MiB and 300 KiB of size (``700 MiB + 300 MiB * 1 / +1024``) will be charged. + + .. _damon_design_damos_quotas_auto_tuning: Aim-oriented Feedback-driven Auto-tuning
Signature · 1 line
2.47.3
SeongJae Park
maintainerRe: (sashiko review) [RFC PATCH 3/9] Docs/mm/damon/design: document fail_charge_{num,denom}
Dropped individual Cc's except myself to reduce unnecessary traffic. I initailly thought it would be good to keep Andrew in the Cc list, but even Andrew may not really interested in each sashiko review for RFC patch, so I dropped him from the list, too.
sashiko found issues. I will fix those in the next revision.
Forwarding sashiko review in a reply format with my inline comments below, for details of my view and doing discussions via mails if needed.
Quoted 18 lines
# review url: https://sashiko.dev/#/patchset/[email protected] # start of sashiko.dev inline review commit bab641e86f0e9820b2ac0a7d4ae493d23c4c50f4 Author: SeongJae Park <[email protected]> Docs/mm/damon/design: document fail_charge_{num,denom}This commit updates the DAMON design document to explain the action-failed memory charging ratio. It provides an example of how to calculate the charged memory when an action fails for a portion of a region.
Quoted 8 lines
Documentation/mm/damon/design.rst +0
-0@@ -565,6 +565,27 @@ interface <sysfs_interface>`, refer to :ref:`weights <sysfs_quotas>` part of the documentation.
Quoted 9 lines
Documentation/mm/damon/design.rst interface <sysfs_interface>`, refer to :ref:`weights <sysfs_quotas>` part of · line 580
Quoted 6 lines
Documentation/mm/damon/design.rst +6
-0+.. _damon_design_damos_quotas_failed_memory_charging_ratio: + +Action-failed Memory Charging Ratio +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +DAMOS action to a given region can fail for sub subsets of the memory of theThis isn't a bug, but should "sub subsets" just be "some subsets" or "subsets"?
Good eye. I will fix this in the next revision.
Quoted 11 lines
Quoted 11 lines
Documentation/mm/damon/design.rst +10
-0+region. For example, if the action is ``pageout`` and the region has some +unreclaimable pages, applying the action to the pages will fail. The amount of +system resource that is taken for such failed action applications is usually +different from that for successful action applications. For such cases, users +can set different charging ratio for such failed memory. The ratio can be +specified using ``fail_charge_num`` and ``fail_charge_denom`` parameters. The +two parameters represent the numerator and denominator of the ratio. + +For example, let's suppose a DAMOS action is applied to a region of 1 GiB size. +The action is successfully applied to only 700 MiB of the region.
Quoted 8 lines
Documentation/mm/damon/design.rst interface <sysfs_interface>`, refer to :ref:`weights <sysfs_quotas>` part of · line 593
Quoted 3 lines
Documentation/mm/damon/design.rst +3
-0+``fail_charge_num`` and ``fail_charge_denom`` are set to ``1`` and ``1024``, +respectively. Then only 700 MiB and 300 KiB of size (``700 MiB + 300 MiB * 1 / +1024``) will be charged.Is this calculation accurate? Since 1 GiB is 1024 MiB, if 700 MiB are successfully applied, the remaining failed region would be 324 MiB rather than 300 MiB. Does the example intentionally use 1 GiB = 1000 MiB, or should the remaining portion be updated to 324 MiB?
Nice finding. I will fix this in the next revision.
Thanks,
SJ
Quoted 4 lines
# end of sashiko.dev inline review # review url: https://sashiko.dev/#/patchset/[email protected]
# hkml [1] generated a draft of this mail. You can regenerate # this using below command: # # hkml patch sashiko_dev --for_forwarding \ # [email protected] # # [1] https://github.com/sjp38/hackermail
SeongJae Park
maintainerRFC PATCH 4/9 Docs/admin-guide/mm/damon/usage: document fail_charge_{num,denom} files
In reply to SeongJae ParkUpdate DAMON usage document for the DAMOS action failed regions quota charge ratio control sysfs files.
--- Documentation/admin-guide/mm/damon/usage.rst | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
Documentation/admin-guide/mm/damon/usage.rst +14 -4
@@ -84,7 +84,9 @@ comma (","). │ │ │ │ │ │ │ │ sz/min,max │ │ │ │ │ │ │ │ nr_accesses/min,max │ │ │ │ │ │ │ │ age/min,max - │ │ │ │ │ │ │ :ref:`quotas <sysfs_quotas>`/ms,bytes,reset_interval_ms,effective_bytes,goal_tuner + │ │ │ │ │ │ │ :ref:`quotas <sysfs_quotas>`/ms,bytes,reset_interval_ms, + │ │ │ │ │ │ │ effective_bytes,goal_tuner, + │ │ │ │ │ │ │ fail_charge_num,fail_charge_denom │ │ │ │ │ │ │ │ weights/sz_permil,nr_accesses_permil,age_permil │ │ │ │ │ │ │ │ :ref:`goals <sysfs_schemes_quota_goals>`/nr_goals │ │ │ │ │ │ │ │ │ 0/target_metric,target_value,current_value,nid,path
@@ -381,9 +383,10 @@ schemes/<N>/quotas/ The directory for the :ref:`quotas <damon_design_damos_quotas>` of the given DAMON-based operation scheme. -Under ``quotas`` directory, five files (``ms``, ``bytes``, -``reset_interval_ms``, ``effective_bytes`` and ``goal_tuner``) and two -directories (``weights`` and ``goals``) exist. +Under ``quotas`` directory, seven files (``ms``, ``bytes``, +``reset_interval_ms``, ``effective_bytes``, ``goal_tuner``, ``fail_charge_num`` +and ``fail_charge_denom``) and two directories (``weights`` and ``goals``) +exist. You can set the ``time quota`` in milliseconds, ``size quota`` in bytes, and ``reset interval`` in milliseconds by writing the values to the three files,
@@ -402,6 +405,13 @@ the background design of the feature and the name of the selectable algorithms. Refer to :ref:`goals directory <sysfs_schemes_quota_goals>` for the goals setup. +You can set the action-failed memory quota charging ratio by writing the +numerator and the denominator for the ratio to ``fail_charge_num`` and +`fail_charge_denom`` files, respectively. Reading those file will return the +current set values. Refer to :ref:`design +<damon_design_damos_quotas_failed_memory_charging_ratio>` for more details of +the ratio feature. + The time quota is internally transformed to a size quota. Between the transformed size quota and user-specified size quota, smaller one is applied. Based on the user-specified :ref:`goal <sysfs_schemes_quota_goals>`, the
Signature · 1 line
2.47.3
SeongJae Park
maintainerRe: (sashiko review) [RFC PATCH 4/9] Docs/admin-guide/mm/damon/usage: document fail_charge_{num,denom} files
Dropped individual recipients from Cc list, to reduce unnecessary traffic.
TL; DR: sashiko found real issues. I will fix those in the next revision.
Forwarding sashiko review in a reply format with my inline comments below, for details of my view and doing discussions via mails if needed.
Quoted 19 lines
# review url: https://sashiko.dev/#/patchset/[email protected] # start of sashiko.dev inline review commit 5f8a4cfde3d93d0a4d4ac3d9a57f14f310c43e02 Author: SeongJae Park <[email protected]>Docs/admin-guide/mm/damon/usage: document fail_charge_{num,denom} files
Update DAMON usage document for the DAMOS action failed regions quota charge ratio control sysfs files.
Quoted 4 lines
Documentation/admin-guide/mm/damon/usage.rst +0
-0[ ... ]
Quoted 4 lines
Documentation/admin-guide/mm/damon/usage.rst +0
-0@@ -398,6 +401,13 @@ the background design of the feature and the name of the selectable algorithms. Refer to :ref:`goals directory <sysfs_schemes_quota_goals>` for the goals setup.
Quoted 8 lines
Documentation/admin-guide/mm/damon/usage.rst the background design of the feature and the name of the selectable algorithms. · line 410
Quoted 3 lines
Documentation/admin-guide/mm/damon/usage.rst +3
-0+You can set the action-failed memory quota charging ratio by writing the +numerator and the denominator for the ratio to ``fail_charge_num`` and +`fail_charge_denom`` files, respectively. Reading those file will return theThis isn't a bug, but
fail_charge_denomhas a single leading backtick and double trailing backticks.Additionally, should "Reading those file" be "Reading those files"?
Good catch! I will fix those in the next spin.
Thanks,
SJ
Quoted 10 lines
Documentation/admin-guide/mm/damon/usage.rst the background design of the feature and the name of the selectable algorithms. · line 415
Quoted 6 lines
Documentation/admin-guide/mm/damon/usage.rst +4
-0+current set values. Refer to :ref:`design +<damon_design_damos_quotas_failed_memory_charging_ratio>` for more details of +the ratio feature. + The time quota is internally transformed to a size quota. Between the# end of sashiko.dev inline review # review url: https://sashiko.dev/#/patchset/[email protected]
# hkml [1] generated a draft of this mail. You can regenerate # this using below command: # # hkml patch sashiko_dev --for_forwarding \ # [email protected] # # [1] https://github.com/sjp38/hackermail
SeongJae Park
maintainerRFC PATCH 5/9 Docs/ABI/damon: document fail_charge_{num,denom}
In reply to SeongJae ParkUpdate DAMON ABI document for the DAMOS action failed regions quota charge ratio control sysfs files.
--- Documentation/ABI/testing/sysfs-kernel-mm-damon | 12 ++++++++++++ 1 file changed, 12 insertions(+)
Documentation/ABI/testing/sysfs-kernel-mm-damon +12 -0
@@ -329,6 +329,18 @@ Contact: SeongJae Park <[email protected]> Description: Writing to and reading from this file sets and gets the goal-based effective quota auto-tuning algorithm to use. +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/quotas/fail_charge_num +Date: Mar 2026 +Contact: SeongJae Park <[email protected]> +Description: Writing to and reading from this file sets and gets the + action-failed memory quota charging ratio numerator. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/quotas/fail_charge_denom +Date: Mar 2026 +Contact: SeongJae Park <[email protected]> +Description: Writing to and reading from this file sets and gets the + action-failed memory quota charging ratio denominator. + What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/quotas/weights/sz_permil Date: Mar 2022 Contact: SeongJae Park <[email protected]>
Signature · 1 line
2.47.3
SeongJae Park
maintainerRFC PATCH 6/9 mm/damon/tests/core-kunit: test fail_charge_{num,denom} committing
In reply to SeongJae ParkExtend damos_test_commit_quotas() kunit test to ensure damos_commit_quota() handles fail_charge_{num,denom} parameters.
--- mm/damon/tests/core-kunit.h | 6 ++++++ 1 file changed, 6 insertions(+)
mm/damon/tests/core-kunit.h +6 -0
@@ -694,6 +694,8 @@ static void damos_test_commit_quota(struct kunit *test) .ms = 2, .sz = 3, .goal_tuner = DAMOS_QUOTA_GOAL_TUNER_CONSIST, + .fail_charge_num = 2, + .fail_charge_denom = 3, .weight_sz = 4, .weight_nr_accesses = 5, .weight_age = 6,
@@ -703,6 +705,8 @@ static void damos_test_commit_quota(struct kunit *test) .ms = 8, .sz = 9, .goal_tuner = DAMOS_QUOTA_GOAL_TUNER_TEMPORAL, + .fail_charge_num = 1, + .fail_charge_denom = 1024, .weight_sz = 10, .weight_nr_accesses = 11, .weight_age = 12,
@@ -717,6 +721,8 @@ static void damos_test_commit_quota(struct kunit *test)KUNIT_EXPECT_EQ (test, dst.ms, src.ms);KUNIT_EXPECT_EQ (test, dst.sz, src.sz);KUNIT_EXPECT_EQ (test, dst.goal_tuner, src.goal_tuner); +KUNIT_EXPECT_EQ (test, dst.fail_charge_num,1 ); +KUNIT_EXPECT_EQ (test, dst.fail_charge_denom,1024 );KUNIT_EXPECT_EQ (test, dst.weight_sz, src.weight_sz);KUNIT_EXPECT_EQ (test, dst.weight_nr_accesses, src.weight_nr_accesses);KUNIT_EXPECT_EQ (test, dst.weight_age, src.weight_age);
Signature · 1 line
2.47.3
SeongJae Park
maintainerRe: (sashiko review) [RFC PATCH 6/9] mm/damon/tests/core-kunit: test fail_charge_{num,denom} committing
Dropped individuals from Cc list to reduce the traffic.
TL; DR: sashiko made a good suggestion to improve this patch. I will do so in the next revision.
Forwarding sashiko review in a reply format with my inline comments below, for details of my view and doing discussions via mails if needed.
Quoted 26 lines
# review url: https://sashiko.dev/#/patchset/[email protected] # start of sashiko.dev inline review commit 2c875b613d1b0d252222336af28714d95bf57930 Author: SeongJae Park <[email protected]>
mm/damon/tests/core-kunit: test fail_charge_{num,denom} committingThis commit extends the
damos_test_commit_quotas()kunit test to verify thatdamos_commit_quota()correctly copies thefail_charge_numandfail_charge_denomparameters.Quoted 4 lines
mm/damon/tests/core-kunit.h +0
-0[ ... ]
mm/damon/tests/core-kunit.h static void damos_test_commit_quota(struct kunit *test) · line 725
Quoted 6 lines
mm/damon/tests/core-kunit.h +2
-0@@ -717,6 +721,8 @@ static void damos_test_commit_quota(struct kunit *test)KUNIT_EXPECT_EQ (test, dst.ms, src.ms);KUNIT_EXPECT_EQ (test, dst.sz, src.sz);KUNIT_EXPECT_EQ (test, dst.goal_tuner, src.goal_tuner); +KUNIT_EXPECT_EQ (test, dst.fail_charge_num,1 ); +KUNIT_EXPECT_EQ (test, dst.fail_charge_denom,1024 );This isn't a bug, but should these assertions use src.fail_charge_num and src.fail_charge_denom instead of the hardcoded 1 and 1024?
Quoted 3 lines
Using the src fields would keep this consistent with the surrounding assertions. It would also prevent the test from becoming brittle if the src structure's initialization values are changed in the future.
Makes sense, I will do so in the next revision.
Thanks,
SJ
Quoted 8 lines
mm/damon/tests/core-kunit.h static void damos_test_commit_quota(struct kunit *test) · line 728
Quoted 4 lines
mm/damon/tests/core-kunit.h +0
-0KUNIT_EXPECT_EQ (test, dst.weight_sz, src.weight_sz);KUNIT_EXPECT_EQ (test, dst.weight_nr_accesses, src.weight_nr_accesses);KUNIT_EXPECT_EQ (test, dst.weight_age, src.weight_age);# end of sashiko.dev inline review # review url: https://sashiko.dev/#/patchset/[email protected]
# hkml [1] generated a draft of this mail. You can regenerate # this using below command: # # hkml patch sashiko_dev --for_forwarding \ # [email protected] # # [1] https://github.com/sjp38/hackermail
SeongJae Park
maintainerRFC PATCH 7/9 selftets/damon/_damon_sysfs: support failed region quota charge ratio
In reply to SeongJae ParkExtend _damon_sysfs.py for DAMOS action failed regions quota charge ratio setup, so that we can add kselftest for the new feature.
--- tools/testing/selftests/damon/_damon_sysfs.py | 21 +++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-)
tools/testing/selftests/damon/_damon_sysfs.py +19 -2
@@ -132,14 +132,17 @@ class DamosQuota: goals = None # quota goals goal_tuner = None # quota goal tuner reset_interval_ms = None # quota reset interval + fail_charge_num = None + fail_charge_denom = None weight_sz_permil = None weight_nr_accesses_permil = None weight_age_permil = None scheme = None # owner scheme def __init__(self, sz=0, ms=0, goals=None, goal_tuner='consist', - reset_interval_ms=0, weight_sz_permil=0, - weight_nr_accesses_permil=0, weight_age_permil=0): + reset_interval_ms=0, fail_charge_num=0, fail_charge_denom=0, + weight_sz_permil=0, weight_nr_accesses_permil=0, + weight_age_permil=0): self.sz = sz self.ms = ms self.reset_interval_ms = reset_interval_ms
@@ -151,6 +154,8 @@ class DamosQuota: for idx, goal in enumerate(self.goals): goal.idx = idx goal.quota = self + self.fail_charge_num = fail_charge_num + self.fail_charge_denom = fail_charge_denom def sysfs_dir(self): return os.path.join(self.scheme.sysfs_dir(), 'quotas')
@@ -197,6 +202,18 @@ class DamosQuota: os.path.join(self.sysfs_dir(), 'goal_tuner'), self.goal_tuner) if err is not None: return err + + err = write_file( + os.path.join(self.sysfs_dir(), 'fail_charge_num'), + self.fail_charge_num) + if err is not None: + return err + err = write_file( + os.path.join(self.sysfs_dir(), 'fail_charge_denom'), + self.fail_charge_denom) + if err is not None: + return err + return None class DamosWatermarks:
Signature · 1 line
2.47.3
SeongJae Park
maintainerRFC PATCH 8/9 selftests/damon/drgn_dump_damon_status: support failed region quota charge ratio
In reply to SeongJae ParkExtend drgn_dump_damon_status.py to dump DAMON internal state for DAMOS action failed regions quota charge ratio, to be able to show if the internal state for the feature is working, with future DAMON selftests.
--- tools/testing/selftests/damon/drgn_dump_damon_status.py | 2 ++ 1 file changed, 2 insertions(+)
tools/testing/selftests/damon/drgn_dump_damon_status.py +2 -0
@@ -112,6 +112,8 @@ def damos_quota_to_dict(quota): ['goals', damos_quota_goals_to_list], ['goal_tuner', int], ['esz', int], + ['fail_charge_num', int], + ['fail_charge_denom', int], ['weight_sz', int], ['weight_nr_accesses', int], ['weight_age', int],
Signature · 1 line
2.47.3
SeongJae Park
maintainerRFC PATCH 9/9 selftets/damon/sysfs.py: test failed region quota charge ratio
In reply to SeongJae ParkExtend sysfs.py DAMON selftest to setup DAMOS action failed region quota charge ratio and assert the setup is made into DAMON internal state.
--- tools/testing/selftests/damon/sysfs.py | 6 ++++++ 1 file changed, 6 insertions(+)
tools/testing/selftests/damon/sysfs.py +6 -0
@@ -73,6 +73,10 @@ def assert_quota_committed(quota, dump): } assert_true(dump['goal_tuner'] == tuner_val[quota.goal_tuner], 'goal_tuner', dump) + assert_true(dump['fail_charge_num'] == quota.fail_charge_num, + 'fail_charge_num', dump) + assert_true(dump['fail_charge_denom'] == quota.fail_charge_denom, + 'fail_charge_denom', dump) assert_true(dump['weight_sz'] == quota.weight_sz_permil, 'weight_sz', dump) assert_true(dump['weight_nr_accesses'] == quota.weight_nr_accesses_permil, 'weight_nr_accesses', dump)
@@ -277,6 +281,8 @@ def main(): nid=1)], goal_tuner='temporal', reset_interval_ms=1500, + fail_charge_num=1, + fail_charge_denom=4096, weight_sz_permil=20, weight_nr_accesses_permil=200, weight_age_permil=1000),
Signature · 1 line
2.47.3
SeongJae Park
maintainerRe: (sashiko status) [RFC PATCH 0/9] mm/damon: introduce DAMOS failed region quota charge ratio
In reply to SeongJae ParkDropped individuals from Cc list to reduce the traffic.
TL; DR: sashiko made a few useful findings. I will address those in the next revision.
Forwarding sashiko.dev review status for the overall picture. Read my replies to 'ISSUES MAY FOUND' patches for more details.
# review url: https://sashiko.dev/#/patchset/[email protected]
- [RFC PATCH 1/9] mm/damon/core: introduce failed region quota charge ratio
- status: Reviewed
- review: ISSUES MAY FOUND
- [RFC PATCH 2/9] mm/damon/sysfs-schemes: implement fail_charge_{num,denom} files
- status: Reviewed
- review: ISSUES MAY FOUND
- [RFC PATCH 3/9] Docs/mm/damon/design: document fail_charge_{num,denom}
- status: Reviewed
- review: ISSUES MAY FOUND
- [RFC PATCH 4/9] Docs/admin-guide/mm/damon/usage: document fail_charge_{num,denom} files
- status: Reviewed
- review: ISSUES MAY FOUND
- [RFC PATCH 5/9] Docs/ABI/damon: document fail_charge_{num,denom}
- status: Reviewed
- review: No issues found.
- [RFC PATCH 6/9] mm/damon/tests/core-kunit: test fail_charge_{num,denom} committing
- status: Reviewed
- review: ISSUES MAY FOUND
- [RFC PATCH 7/9] selftets/damon/_damon_sysfs: support failed region quota charge ratio
- status: Reviewed
- review: No issues found.
- [RFC PATCH 8/9] selftests/damon/drgn_dump_damon_status: support failed region quota charge ratio
- status: Reviewed
- review: No issues found.
- [RFC PATCH 9/9] selftets/damon/sysfs.py: test failed region quota charge ratio
- status: Reviewed
- review: No issues found.
# hkml [1] generated a draft of this mail. It can be regenerated # using below command: # # hkml patch sashiko_dev --thread_status --for_forwarding \ # [email protected] # # [1] https://github.com/sjp38/hackermail
Thanks,
SJ