lkml.org 
[lkml]   [2021]   [Jun]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RFC v2 02/14] mm/damon/damos: Make schemes aggressiveness controllable
    Date
    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
    \
     
     \ /
      Last update: 2021-06-08 13:53    [W:4.749 / U:0.016 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site