diff mbox series

[v22,04/18] mm/damon: Track dynamic monitoring target regions update

Message ID 20201020085940.13875-5-sjpark@amazon.com (mailing list archive)
State New, archived
Headers show
Series Introduce Data Access MONitor (DAMON) | expand

Commit Message

SeongJae Park Oct. 20, 2020, 8:59 a.m. UTC 
From: SeongJae Park <sjpark@amazon.de>

The monitoring target address range can be dynamically changed.  For
example, virtual memory could be dynamically mapped and unmapped.
Physical memory could be hot-plugged.

As the changes could be quite frequent in some cases, DAMON checks the
dynamic memory mapping changes and applies it to the abstracted target
area only for each of a user-specified time interval, ``regions update
interval``.

Signed-off-by: SeongJae Park <sjpark@amazon.de>
Reviewed-by: Leonard Foerster <foersleo@amazon.de>
---
 include/linux/damon.h | 22 +++++++++++++++++-----
 mm/damon/core.c       | 22 ++++++++++++++++++++--
 2 files changed, 37 insertions(+), 7 deletions(-)

Comments

Shakeel Butt Nov. 25, 2020, 3:29 p.m. UTC | #1 
On Tue, Oct 20, 2020 at 2:02 AM SeongJae Park <sjpark@amazon.com> wrote:
>
> From: SeongJae Park <sjpark@amazon.de>
>
> The monitoring target address range can be dynamically changed.  For
> example, virtual memory could be dynamically mapped and unmapped.
> Physical memory could be hot-plugged.
>
> As the changes could be quite frequent in some cases,

Which cases? Usually address space changes are very infrequent for
performance reasons.

> DAMON checks the
> dynamic memory mapping changes and applies it to the abstracted target
> area only for each of a user-specified time interval, ``regions update
> interval``.
>
> Signed-off-by: SeongJae Park <sjpark@amazon.de>
> Reviewed-by: Leonard Foerster <foersleo@amazon.de>
[snip]
>   * Check whether current monitoring should be stopped
>   *
> @@ -612,6 +625,11 @@ static int kdamond_fn(void *data)
>                         kdamond_reset_aggregated(ctx);
>                         kdamond_split_regions(ctx);
>                 }
> +
> +               if (kdamond_need_update_regions(ctx)) {
> +                       kdamond_call_prmt(ctx, update_target_regions);

The implementation of update_target_regions callback should be part of
this patch.


> +                       sz_limit = damon_region_sz_limit(ctx);
> +               }
>         }
>         damon_for_each_target(t, ctx) {
>                 damon_for_each_region_safe(r, next, t)
> --
> 2.17.1
>
SeongJae Park Nov. 26, 2020, 12:18 p.m. UTC | #2 
On Wed, 25 Nov 2020 07:29:57 -0800 Shakeel Butt <shakeelb@google.com> wrote:

> On Tue, Oct 20, 2020 at 2:02 AM SeongJae Park <sjpark@amazon.com> wrote:
> >
> > From: SeongJae Park <sjpark@amazon.de>
> >
> > The monitoring target address range can be dynamically changed.  For
> > example, virtual memory could be dynamically mapped and unmapped.
> > Physical memory could be hot-plugged.
> >
> > As the changes could be quite frequent in some cases,
> 
> Which cases? Usually address space changes are very infrequent for
> performance reasons.

It depends on the application, but there are some cases for the mmap[1].
ebizzy, the popular benchmarks in mm community is also one such application.

[1] Section 4.3, https://dl.acm.org/doi/pdf/10.1145/3342195.3387527

> 
> > DAMON checks the
> > dynamic memory mapping changes and applies it to the abstracted target
> > area only for each of a user-specified time interval, ``regions update
> > interval``.
> >
> > Signed-off-by: SeongJae Park <sjpark@amazon.de>
> > Reviewed-by: Leonard Foerster <foersleo@amazon.de>
> [snip]
> >   * Check whether current monitoring should be stopped
> >   *
> > @@ -612,6 +625,11 @@ static int kdamond_fn(void *data)
> >                         kdamond_reset_aggregated(ctx);
> >                         kdamond_split_regions(ctx);
> >                 }
> > +
> > +               if (kdamond_need_update_regions(ctx)) {
> > +                       kdamond_call_prmt(ctx, update_target_regions);
> 
> The implementation of update_target_regions callback should be part of
> this patch.

Agreed, will make so in the next version.


Thanks,
SeongJae Park

> 
> 
> > +                       sz_limit = damon_region_sz_limit(ctx);
> > +               }
> >         }
> >         damon_for_each_target(t, ctx) {
> >                 damon_for_each_region_safe(r, next, t)
> > --
> > 2.17.1
> >
diff mbox series

Patch

diff --git a/include/linux/damon.h b/include/linux/damon.h
index 0797bdfbfc24..b8562814751e 100644
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -60,6 +60,7 @@  struct damon_ctx;
  * struct damon_primitive	Monitoring primitives for given use cases.
  *
  * @init_target_regions:	Constructs initial monitoring target regions.
+ * @update_target_regions:	Updates monitoring target regions.
  * @prepare_access_checks:	Prepares next access check of target regions.
  * @check_accesses:		Checks the access of target regions.
  * @target_valid:		Determine if the target is valid.
@@ -68,12 +69,17 @@  struct damon_ctx;
  * DAMON can be extended for various address spaces and usages.  For this,
  * users should register the low level primitives for their target address
  * space and usecase via the &damon_ctx.primitive.  Then, the monitoring thread
- * calls @init_target_regions before starting the monitoring and
+ * calls @init_target_regions before starting the monitoring,
+ * @update_target_regions for each @regions_update_interval, and
  * @prepare_access_checks, @check_accesses, and @target_valid for each
  * @sample_interval.
+
  *
  * @init_target_regions should construct proper monitoring target regions and
  * link those to the DAMON context struct.
+ * @update_target_regions should update the monitoring target regions for
+ * current status.
+
  * @prepare_access_checks should manipulate the monitoring regions to be
  * prepare for the next access check.
  * @check_accesses should check the accesses to each region that made after the
@@ -87,6 +93,7 @@  struct damon_ctx;
  */
 struct damon_primitive {
 	void (*init_target_regions)(struct damon_ctx *context);
+	void (*update_target_regions)(struct damon_ctx *context);
 	void (*prepare_access_checks)(struct damon_ctx *context);
 	unsigned int (*check_accesses)(struct damon_ctx *context);
 	bool (*target_valid)(struct damon_target *target);
@@ -132,13 +139,16 @@  struct damon_callback {
  *
  * @sample_interval:		The time between access samplings.
  * @aggr_interval:		The time between monitor results aggregations.
+ * @regions_update_interval:	The time between monitor regions updates.
  * @min_nr_regions:		The minimum number of monitoring regions.
  * @max_nr_regions:		The maximum number of monitoring regions.
  *
  * For each @sample_interval, DAMON checks whether each region is accessed or
  * not.  It aggregates and keeps the access information (number of accesses to
- * each region) for @aggr_interval time.  All time intervals are in
- * micro-seconds.
+ * each region) for @aggr_interval time.  DAMON also checks whether the target
+ * memory regions need update (e.g., by ``mmap()`` calls from the application,
+ * in case of virtual memory monitoring) and applies the changes for each
+ * @regions_update_interval.  All time intervals are in micro-seconds.
  *
  * @kdamond:		Kernel thread who does the monitoring.
  * @kdamond_stop:	Notifies whether kdamond should stop.
@@ -167,10 +177,12 @@  struct damon_callback {
 struct damon_ctx {
 	unsigned long sample_interval;
 	unsigned long aggr_interval;
+	unsigned long regions_update_interval;
 	unsigned long min_nr_regions;
 	unsigned long max_nr_regions;
 
 	struct timespec64 last_aggregation;
+	struct timespec64 last_regions_update;
 
 	struct task_struct *kdamond;
 	bool kdamond_stop;
@@ -216,8 +228,8 @@  unsigned int damon_nr_regions(struct damon_target *t);
 
 int damon_set_targets(struct damon_ctx *ctx,
 		unsigned long *ids, ssize_t nr_ids);
-int damon_set_attrs(struct damon_ctx *ctx,
-		unsigned long sample_int, unsigned long aggr_int,
+int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int,
+		unsigned long aggr_int, unsigned long regions_update_int,
 		unsigned long min_nr_reg, unsigned long max_nr_reg);
 
 int damon_nr_running_ctxs(void);
diff --git a/mm/damon/core.c b/mm/damon/core.c
index ed364b42721d..36428327e848 100644
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -167,6 +167,7 @@  int damon_set_targets(struct damon_ctx *ctx,
  * damon_set_attrs() - Set attributes for the monitoring.
  * @ctx:		monitoring context
  * @sample_int:		time interval between samplings
+ * @regions_update_int:	time interval between target regions update
  * @aggr_int:		time interval between aggregations
  * @min_nr_reg:		minimal number of regions
  * @max_nr_reg:		maximum number of regions
@@ -176,8 +177,8 @@  int damon_set_targets(struct damon_ctx *ctx,
  *
  * Return: 0 on success, negative error code otherwise.
  */
-int damon_set_attrs(struct damon_ctx *ctx,
-		    unsigned long sample_int, unsigned long aggr_int,
+int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int,
+		    unsigned long aggr_int, unsigned long regions_update_int,
 		    unsigned long min_nr_reg, unsigned long max_nr_reg)
 {
 	if (min_nr_reg < 3) {
@@ -193,6 +194,7 @@  int damon_set_attrs(struct damon_ctx *ctx,
 
 	ctx->sample_interval = sample_int;
 	ctx->aggr_interval = aggr_int;
+	ctx->regions_update_interval = regions_update_int;
 	ctx->min_nr_regions = min_nr_reg;
 	ctx->max_nr_regions = max_nr_reg;
 
@@ -529,6 +531,17 @@  static void kdamond_split_regions(struct damon_ctx *ctx)
 	last_nr_regions = nr_regions;
 }
 
+/*
+ * Check whether it is time to check and apply the target monitoring regions
+ *
+ * Returns true if it is.
+ */
+static bool kdamond_need_update_regions(struct damon_ctx *ctx)
+{
+	return damon_check_reset_time_interval(&ctx->last_regions_update,
+			ctx->regions_update_interval);
+}
+
 /*
  * Check whether current monitoring should be stopped
  *
@@ -612,6 +625,11 @@  static int kdamond_fn(void *data)
 			kdamond_reset_aggregated(ctx);
 			kdamond_split_regions(ctx);
 		}
+
+		if (kdamond_need_update_regions(ctx)) {
+			kdamond_call_prmt(ctx, update_target_regions);
+			sz_limit = damon_region_sz_limit(ctx);
+		}
 	}
 	damon_for_each_target(t, ctx) {
 		damon_for_each_region_safe(r, next, t)