From: SeongJae Park <sj38.park@gmail.com>
To: akpm@linux-foundation.org
Cc: SeongJae Park <sjpark@amazon.de>,
Jonathan.Cameron@Huawei.com, acme@kernel.org,
alexander.shishkin@linux.intel.com, amit@kernel.org,
benh@kernel.crashing.org, brendanhiggins@google.com,
corbet@lwn.net, david@redhat.com, dwmw@amazon.com,
elver@google.com, fan.du@intel.com, foersleo@amazon.de,
greg@kroah.com, gthelen@google.com, guoju.fgj@alibaba-inc.com,
jgowans@amazon.com, mgorman@suse.de, minchan@kernel.org,
mingo@redhat.com, namhyung@kernel.org, peterz@infradead.org,
riel@surriel.com, rientjes@google.com, rostedt@goodmis.org,
rppt@kernel.org, shakeelb@google.com, shuah@kernel.org,
sj38.park@gmail.com, snu@zelle79.org, vbabka@suse.cz,
vdavydov.dev@gmail.com, zgf574564920@gmail.com,
linux-damon@amazon.com, linux-mm@kvack.org,
linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: [RFC v2 02/14] mm/damon/damos: Make schemes aggressiveness controllable
Date: Tue, 8 Jun 2021 11:52:42 +0000 [thread overview]
Message-ID: <20210608115254.11930-3-sj38.park@gmail.com> (raw)
In-Reply-To: <20210608115254.11930-1-sj38.park@gmail.com>
From: SeongJae Park <sjpark@amazon.de>
If there are too large memory regions fulfilling the target data access
pattern of a DAMON-based operation scheme, applying the action of the
scheme could consume too much CPU. To avoid that, this commit
implements a limit for the action application speed. Using the feature,
the client can set up to how much amount of memory regions the action
could applied within specific time duration.
Signed-off-by: SeongJae Park <sjpark@amazon.de>
---
include/linux/damon.h | 34 ++++++++++++++++++++++++----
mm/damon/core.c | 52 ++++++++++++++++++++++++++++++++++++++-----
mm/damon/dbgfs.c | 4 +++-
3 files changed, 79 insertions(+), 11 deletions(-)
diff --git a/include/linux/damon.h b/include/linux/damon.h
index 684a3603ddac..35068b0ece6f 100644
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -87,6 +87,25 @@ enum damos_action {
DAMOS_STAT, /* Do nothing but only record the stat */
};
+/**
+ * struct damos_speed_limit - Controls the aggressiveness of the given scheme.
+ * @sz: Scheme action amount limit in bytes.
+ * @ms: Scheme action amount charge duration.
+ *
+ * To avoid consuming too much CPU time for applying the &struct damos->action
+ * to large memory, DAMON applies it to only up to &sz bytes within &ms.
+ *
+ * If &sz is 0, the limit is disabled.
+ */
+struct damos_speed_limit {
+ unsigned long sz;
+ unsigned long ms;
+
+/* private: for limit accounting */
+ unsigned long charged_sz;
+ unsigned long charged_from;
+};
+
/**
* struct damos - Represents a Data Access Monitoring-based Operation Scheme.
* @min_sz_region: Minimum size of target regions.
@@ -96,13 +115,19 @@ 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.
+ * @limit: Control the aggressiveness of this scheme.
* @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
- * regions fit in the condition and updates the statistics. Note that both
- * the minimums and the maximums are inclusive.
+ * For each aggregation interval, DAMON finds regions which fit in the
+ * condition (&min_sz_region, &max_sz_region, &min_nr_accesses,
+ * &max_nr_accesses, &min_age_region, &max_age_region) and applies &action to
+ * those. To avoid consuming too much CPU for the &action, &limit is used.
+ *
+ * After applying the &action to each region, &stat_count and &stat_sz is
+ * updated to reflect the number of regions and total size of regions that the
+ * &action is applied.
*/
struct damos {
unsigned long min_sz_region;
@@ -112,6 +137,7 @@ struct damos {
unsigned int min_age_region;
unsigned int max_age_region;
enum damos_action action;
+ struct damos_speed_limit limit;
unsigned long stat_count;
unsigned long stat_sz;
struct list_head list;
@@ -335,7 +361,7 @@ struct damos *damon_new_scheme(
unsigned long min_sz_region, unsigned long 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);
+ enum damos_action action, struct damos_speed_limit *limit);
void damon_add_scheme(struct damon_ctx *ctx, struct damos *s);
void damon_destroy_scheme(struct damos *s);
diff --git a/mm/damon/core.c b/mm/damon/core.c
index a33b3a3b9e57..4ac4a9aa2514 100644
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -85,7 +85,7 @@ struct damos *damon_new_scheme(
unsigned long min_sz_region, unsigned long 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)
+ enum damos_action action, struct damos_speed_limit *limit)
{
struct damos *scheme;
@@ -103,6 +103,11 @@ struct damos *damon_new_scheme(
scheme->stat_sz = 0;
INIT_LIST_HEAD(&scheme->list);
+ scheme->limit.sz = limit->sz;
+ scheme->limit.ms = limit->ms;
+ scheme->limit.charged_sz = 0;
+ scheme->limit.charged_from = 0;
+
return scheme;
}
@@ -536,6 +541,9 @@ static void kdamond_reset_aggregated(struct damon_ctx *c)
}
}
+static void damon_split_region_at(struct damon_ctx *ctx,
+ struct damon_region *r, unsigned long sz_r);
+
static void damon_do_apply_schemes(struct damon_ctx *c,
struct damon_target *t,
struct damon_region *r)
@@ -544,7 +552,14 @@ static void damon_do_apply_schemes(struct damon_ctx *c,
unsigned long sz;
damon_for_each_scheme(s, c) {
+ struct damos_speed_limit *limit = &s->limit;
+
+ /* Check the limit */
+ if (limit->sz && limit->charged_sz >= limit->sz)
+ continue;
+
sz = r->ar.end - r->ar.start;
+ /* Check the target regions condition */
if (sz < s->min_sz_region || s->max_sz_region < sz)
continue;
if (r->nr_accesses < s->min_nr_accesses ||
@@ -552,22 +567,47 @@ static void damon_do_apply_schemes(struct damon_ctx *c,
continue;
if (r->age < s->min_age_region || s->max_age_region < r->age)
continue;
- s->stat_count++;
- s->stat_sz += sz;
- if (c->primitive.apply_scheme)
+
+ /* Apply the scheme */
+ if (c->primitive.apply_scheme) {
+ if (limit->sz && limit->charged_sz + sz > limit->sz) {
+ sz = limit->sz - limit->charged_sz;
+ damon_split_region_at(c, r, sz);
+ }
c->primitive.apply_scheme(c, t, r, s);
+ limit->charged_sz += sz;
+ }
if (s->action != DAMOS_STAT)
r->age = 0;
+
+ /* Update stat */
+ s->stat_count++;
+ s->stat_sz += sz;
}
}
static void kdamond_apply_schemes(struct damon_ctx *c)
{
struct damon_target *t;
- struct damon_region *r;
+ struct damon_region *r, *next_r;
+ struct damos *s;
+
+ damon_for_each_scheme(s, c) {
+ struct damos_speed_limit *limit = &s->limit;
+
+ if (!limit->sz)
+ continue;
+
+ /* Reset charge window if the duration passed */
+ if (time_after_eq(jiffies, limit->charged_from +
+ msecs_to_jiffies(limit->ms))) {
+ limit->charged_from = jiffies;
+ limit->charged_sz = 0;
+ }
+ }
damon_for_each_target(t, c) {
- damon_for_each_region(r, t)
+ damon_for_each_region_safe(r, next_r, t)
damon_do_apply_schemes(c, t, r);
}
}
diff --git a/mm/damon/dbgfs.c b/mm/damon/dbgfs.c
index 5b254eccdb43..4b45b69db697 100644
--- a/mm/damon/dbgfs.c
+++ b/mm/damon/dbgfs.c
@@ -310,6 +310,8 @@ static struct damos **str_to_schemes(const char *str, ssize_t len,
*nr_schemes = 0;
while (pos < len && *nr_schemes < max_nr_schemes) {
+ struct damos_speed_limit limit = {};
+
ret = sscanf(&str[pos], "%lu %lu %u %u %u %u %u%n",
&min_sz, &max_sz, &min_nr_a, &max_nr_a,
&min_age, &max_age, &action, &parsed);
@@ -322,7 +324,7 @@ static struct damos **str_to_schemes(const char *str, ssize_t len,
pos += parsed;
scheme = damon_new_scheme(min_sz, max_sz, min_nr_a, max_nr_a,
- min_age, max_age, action);
+ min_age, max_age, action, &limit);
if (!scheme)
goto fail;
--
2.17.1
next prev parent reply other threads:[~2021-06-08 11:53 UTC|newest]
Thread overview: 15+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-06-08 11:52 [RFC v2 00/14] Introduce DAMON-based Proactive Reclamation SeongJae Park
2021-06-08 11:52 ` [RFC v2 01/14] mm/damon/paddr: Support the pageout scheme SeongJae Park
2021-06-08 11:52 ` SeongJae Park [this message]
2021-06-08 11:52 ` [RFC v2 03/14] damon/core/schemes: Skip already charged targets and regions SeongJae Park
2021-06-08 11:52 ` [RFC v2 04/14] mm/damon/dbgfs: Support schemes speed limit SeongJae Park
2021-06-08 11:52 ` [RFC v2 05/14] mm/damon/selftests: " SeongJae Park
2021-06-08 11:52 ` [RFC v2 06/14] mm/damon/schemes: Prioritize regions within " SeongJae Park
2021-06-08 11:52 ` [RFC v2 07/14] mm/damon/vaddr,paddr: Support pageout prioritization SeongJae Park
2021-06-08 11:52 ` [RFC v2 08/14] mm/damon/dbgfs: Support prioritization weights SeongJae Park
2021-06-08 11:52 ` [RFC v2 09/14] tools/selftests/damon: Update for regions prioritization of schemes SeongJae Park
2021-06-08 11:52 ` [RFC v2 10/14] mm/damon/schemes: Activate schemes based on a watermarks mechanism SeongJae Park
2021-06-08 11:52 ` [RFC v2 11/14] mm/damon/dbgfs: Support watermarks SeongJae Park
2021-06-08 11:52 ` [RFC v2 12/14] selftests/damon: " SeongJae Park
2021-06-08 11:52 ` [RFC v2 13/14] mm/damon: Introduce DAMON-based reclamation SeongJae Park
2021-06-08 11:52 ` [RFC v2 14/14] Documentation/admin-guide/mm/damon: Add a document for DAMON_RECLAIM SeongJae Park
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20210608115254.11930-3-sj38.park@gmail.com \
--to=sj38.park@gmail.com \
--cc=Jonathan.Cameron@Huawei.com \
--cc=acme@kernel.org \
--cc=akpm@linux-foundation.org \
--cc=alexander.shishkin@linux.intel.com \
--cc=amit@kernel.org \
--cc=benh@kernel.crashing.org \
--cc=brendanhiggins@google.com \
--cc=corbet@lwn.net \
--cc=david@redhat.com \
--cc=dwmw@amazon.com \
--cc=elver@google.com \
--cc=fan.du@intel.com \
--cc=foersleo@amazon.de \
--cc=greg@kroah.com \
--cc=gthelen@google.com \
--cc=guoju.fgj@alibaba-inc.com \
--cc=jgowans@amazon.com \
--cc=linux-damon@amazon.com \
--cc=linux-doc@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=mgorman@suse.de \
--cc=minchan@kernel.org \
--cc=mingo@redhat.com \
--cc=namhyung@kernel.org \
--cc=peterz@infradead.org \
--cc=riel@surriel.com \
--cc=rientjes@google.com \
--cc=rostedt@goodmis.org \
--cc=rppt@kernel.org \
--cc=shakeelb@google.com \
--cc=shuah@kernel.org \
--cc=sjpark@amazon.de \
--cc=snu@zelle79.org \
--cc=vbabka@suse.cz \
--cc=vdavydov.dev@gmail.com \
--cc=zgf574564920@gmail.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).