mm/damon/core: merge regions after applying DAMOS schemes

damos_apply_scheme() could split the given region if applying the scheme's
action to the entire region can result in violating the quota-set upper
limit.  Keeping regions that are created by such split operations is
unnecessary overhead.

The overhead would be negligible in the common case because such split
operations could happen only up to the number of installed schemes per
scheme apply interval.  The following commit could make the impact larger,
though.  The following commit will allow the action-failed region to be
charged in a different ratio.  If both the ratio and the remaining quota
is quite small while the region to apply the scheme is quite large and the
action is nearly always failing, a high number of split operations could
happen.

Remove the unnecessary overhead by merging regions after applying schemes
is done for each region.  The merge operation is made only if it will not
lose monitoring information and keep min_nr_regions constraint.  In the
worst case, the max_nr_regions could still be violated until the next
per-aggregation interval merge operation is made.

Link: https://lore.kernel.org/20260428013402.115171-3-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Cc: Brendan Higgins <brendan.higgins@linux.dev>
Cc: David Hildenbrand <david@kernel.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Liam R. Howlett <liam@infradead.org>
Cc: Lorenzo Stoakes <ljs@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/damon/core.c b/mm/damon/core.c
index df51a5661d46273e523014621e7377bc0c82f251..e59f4031d24b3e83caeaf5a6b915bbff2c35d3f7 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -2182,6 +2182,58 @@ static void damon_do_apply_schemes(struct damon_ctx *c,
        }
 }
 
+/*
+ * damos_apply_target() - Apply DAMOS schemes to a given target.
+ * @c:                 monitoring context to apply its DAMOS schemes to..
+ * @t:                 monitoring target to apply the schemes to.
+ * @max_region_sz:     maximum region size for @c.
+ *
+ * This function could split regions for keeping the quota.  To minimize
+ * overhead from the split operations increased number of regions, this
+ * function will also merge regions after the schemes applying attempt is done,
+ * for each region.  The merge operation is made only when it doesn't lose the
+ * monitoring information and not violating @max_region_sz.
+ *
+ * Hence, after this function is called, the total number of regions could
+ * be increased or reduced.  The increase could make max_nr_regions temporarily
+ * be violated, until the next per-aggregation interval regions merge operation
+ * is executed.  The decrease will not violate min_nr_regions though, since it
+ * keeps @max_region_sz.
+ */
+static void damos_apply_target(struct damon_ctx *c, struct damon_target *t,
+               unsigned long max_region_sz)
+{
+       struct damon_region *r;
+
+       damon_for_each_region(r, t) {
+               struct damon_region *prev_r;
+
+               damon_do_apply_schemes(c, t, r);
+               /*
+                * damon_do_apply_scheems() could split the region for the
+                * quota.  Keeping the new slices is an overhead.  Merge back
+                * the slices into the previous region if it doesn't lose any
+                * information and not violating the max_region_sz.
+                */
+               if (damon_first_region(t) == r)
+                       continue;
+               prev_r = damon_prev_region(r);
+               if (prev_r->ar.end != r->ar.start)
+                       continue;
+               if (prev_r->age != r->age)
+                       continue;
+               if (prev_r->last_nr_accesses != r->last_nr_accesses)
+                       continue;
+               if (prev_r->nr_accesses != r->nr_accesses)
+                       continue;
+               if (r->ar.end - prev_r->ar.start > max_region_sz)
+                       continue;
+               prev_r->ar.end = r->ar.end;
+               damon_destroy_region(r, t);
+               r = prev_r;
+       }
+}
+
 /*
  * damon_feed_loop_next_input() - get next input to achieve a target score.
  * @last_input The last input.
@@ -2674,9 +2726,9 @@ static void damos_trace_stat(struct damon_ctx *c, struct damos *s)
 static void kdamond_apply_schemes(struct damon_ctx *c)
 {
        struct damon_target *t;
-       struct damon_region *r;
        struct damos *s;
        bool has_schemes_to_apply = false;
+       unsigned long max_region_sz;
 
        damon_for_each_scheme(s, c) {
                if (time_before(c->passed_sample_intervals, s->next_apply_sis))
@@ -2693,13 +2745,12 @@ static void kdamond_apply_schemes(struct damon_ctx *c)
        if (!has_schemes_to_apply)
                return;
 
+       max_region_sz = damon_region_sz_limit(c);
        mutex_lock(&c->walk_control_lock);
        damon_for_each_target(t, c) {
                if (c->ops.target_valid && c->ops.target_valid(t) == false)
                        continue;
-
-               damon_for_each_region(r, t)
-                       damon_do_apply_schemes(c, t, r);
+               damos_apply_target(c, t, max_region_sz);
        }
 
        damon_for_each_scheme(s, c) {