'struct damos_quota' is not small now. Split out fields for quota goal
to a separate struct for easier reading.
Signed-off-by: SeongJae Park <sj@xxxxxxxxxx>
---
include/linux/damon.h | 36 ++++++++++++++++++++++--------------
mm/damon/core.c | 13 +++++++------
mm/damon/sysfs-schemes.c | 10 +++++-----
3 files changed, 34 insertions(+), 25 deletions(-)
diff --git a/include/linux/damon.h b/include/linux/damon.h
index bd17b14828bc..2fe345adf6b2 100644
--- 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 0656966a6fc4..fe4209672121 100644
--- 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 9d90e7b757b7..85ef58f98a87 100644
--- 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;
}
}
--
2.39.2
