mm/damon/core: split out quota goal related fields to a struct

'struct damos_quota' is not small now.  Split out fields for quota goal to
a separate struct for easier reading.

Link: https://lkml.kernel.org/r/20240219194431.159606-8-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/damon.h b/include/linux/damon.h
index bd17b14828bc27ea87b43cca25a29f6ae0fa8127..2fe345adf6b2c532a19e9f94ad81c01cf42db58f 100644 (file)
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -126,13 +126,28 @@ enum damos_action {
        NR_DAMOS_ACTIONS,
 };
 
+/**
+ * struct damos_quota_goal - DAMOS scheme quota auto-tuning goal.
+ * @get_score:         Function for getting current score of the goal.
+ * @get_score_arg:     Parameter for @get_score
+ *
+ * Data structure for getting the current score of the quota tuning goal.
+ * Calling @get_score with @get_score_arg as the parameter should return the
+ * current score.  Then the score is entered to DAMON's internal feedback loop
+ * mechanism to get the auto-tuned quota.  The goal of the tuning is getting
+ * the feedback score value of 10,000.
+ */
+struct damos_quota_goal {
+       unsigned long (*get_score)(void *arg);
+       void *get_score_arg;
+};
+
 /**
  * struct damos_quota - Controls the aggressiveness of the given scheme.
  * @reset_interval:    Charge reset interval in milliseconds.
  * @ms:                        Maximum milliseconds that the scheme can use.
  * @sz:                        Maximum bytes of memory that the action can be applied.
- * @get_score:         Feedback function for self-tuning quota.
- * @get_score_arg:     Parameter for @get_score
+ * @goal:              Quota auto-tuning goal.
  * @esz:               Effective size quota in bytes.
  *
  * @weight_sz:         Weight of the region's size for prioritization.
@@ -151,16 +166,10 @@ enum damos_action {
  * throughput of the scheme's action.  DAMON then compares it against &sz and
  * uses smaller one as the effective quota.
  *
- * If @get_score function pointer is set, DAMON calls it back with
- * @get_score_arg and get the return value of it for every @reset_interval.
- * Then, DAMON adjusts the effective quota using the return value as a feedback
- * score to the current quota, using its internal feedback loop algorithm.
- *
- * The feedback loop algorithem assumes the quota input and the feedback score
- * output are in a positive proportional relationship, and the goal of the
- * tuning is getting the feedback screo value of 10,000.  If @ms and/or @sz are
- * set together, those work as a hard limit quota.  If neither @ms nor @sz are
- * set, the mechanism starts from the quota of one byte.
+ * If ->get_score field of @goal is set, DAMON calculates yet another size
+ * quota based on the goal using its internal feedback loop algorithm, for
+ * every @reset_interval.  Then, if the new size quota is smaller than the
+ * effective quota, it uses the new size quota as the effective quota.
  *
  * The resulting effective size quota in bytes is set to @esz.
  *
@@ -174,8 +183,7 @@ struct damos_quota {
        unsigned long reset_interval;
        unsigned long ms;
        unsigned long sz;
-       unsigned long (*get_score)(void *arg);
-       void *get_score_arg;
+       struct damos_quota_goal goal;
        unsigned long esz;
 
        unsigned int weight_sz;

diff --git a/mm/damon/core.c b/mm/damon/core.c
index 0656966a6fc43519a1bae51d059a04c71a0897b8..fe420967212159474a18417e42b120de0ed27f81 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -1083,21 +1083,22 @@ static unsigned long damon_feed_loop_next_input(unsigned long last_input,
        return min_input;
 }
 
-/* Shouldn't be called if quota->ms, quota->sz, and quota->get_score unset */
+/* Called only if quota->ms, quota->sz, or quota->goal.get_score are set */
 static void damos_set_effective_quota(struct damos_quota *quota)
 {
        unsigned long throughput;
        unsigned long esz;
 
-       if (!quota->ms && !quota->get_score) {
+       if (!quota->ms && !quota->goal.get_score) {
                quota->esz = quota->sz;
                return;
        }
 
-       if (quota->get_score) {
+       if (quota->goal.get_score) {
                quota->esz_bp = damon_feed_loop_next_input(
                                max(quota->esz_bp, 10000UL),
-                               quota->get_score(quota->get_score_arg));
+                               quota->goal.get_score(
+                                       quota->goal.get_score_arg));
                esz = quota->esz_bp / 10000;
        }
 
@@ -1107,7 +1108,7 @@ static void damos_set_effective_quota(struct damos_quota *quota)
                                quota->total_charged_ns;
                else
                        throughput = PAGE_SIZE * 1024;
-               if (quota->get_score)
+               if (quota->goal.get_score)
                        esz = min(throughput * quota->ms, esz);
                else
                        esz = throughput * quota->ms;
@@ -1127,7 +1128,7 @@ static void damos_adjust_quota(struct damon_ctx *c, struct damos *s)
        unsigned long cumulated_sz;
        unsigned int score, max_score = 0;
 
-       if (!quota->ms && !quota->sz && !quota->get_score)
+       if (!quota->ms && !quota->sz && !quota->goal.get_score)
                return;
 
        /* New charge window starts */

diff --git a/mm/damon/sysfs-schemes.c b/mm/damon/sysfs-schemes.c
index 9d90e7b757b7653757619fb9dd878a90a635be7e..85ef58f98a87c2f7cba53cd35589e12b3afb4c73 100644 (file)
--- a/mm/damon/sysfs-schemes.c
+++ b/mm/damon/sysfs-schemes.c
@@ -1894,19 +1894,19 @@ static void damos_sysfs_set_quota_score(
        struct damos_sysfs_quota_goal *sysfs_goal;
        int i;
 
-       quota->get_score = NULL;
-       quota->get_score_arg = (void *)0;
+       quota->goal.get_score = NULL;
+       quota->goal.get_score_arg = (void *)0;
        for (i = 0; i < sysfs_goals->nr; i++) {
                sysfs_goal = sysfs_goals->goals_arr[i];
                if (!sysfs_goal->target_value)
                        continue;
 
                /* Higher score makes scheme less aggressive */
-               quota->get_score_arg = (void *)max(
-                               (unsigned long)quota->get_score_arg,
+               quota->goal.get_score_arg = (void *)max(
+                               (unsigned long)quota->goal.get_score_arg,
                                sysfs_goal->current_value * 10000 /
                                sysfs_goal->target_value);
-               quota->get_score = damos_sysfs_get_quota_score;
+               quota->goal.get_score = damos_sysfs_get_quota_score;
        }
 }