mm/damon/schemes: implement statistics feature

To tune the DAMON-based operation schemes, knowing how many and how
large regions are affected by each of the schemes will be helful.  Those
stats could be used for not only the tuning, but also monitoring of the
working set size and the number of regions, if the scheme does not
change the program behavior too much.

For the reason, this implements the statistics for the schemes.  The
total number and size of the regions that each scheme is applied are
exported to users via '->stat_count' and '->stat_sz' of 'struct damos'.
Admins can also check the number by reading 'schemes' debugfs file.  The
last two integers now represents the stats.  To allow collecting the
stats without changing the program behavior, this also adds new scheme
action, 'DAMOS_STAT'.  Note that 'DAMOS_STAT' is not only making no
memory operation actions, but also does not reset the age of regions.

Link: https://lkml.kernel.org/r/20211001125604.29660-6-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Cc: Amit Shah <amit@kernel.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Hildenbrand <david@redhat.com>
Cc: David Rienjes <rientjes@google.com>
Cc: David Woodhouse <dwmw@amazon.com>
Cc: Greg Thelen <gthelen@google.com>
Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Leonard Foerster <foersleo@amazon.de>
Cc: Marco Elver <elver@google.com>
Cc: Markus Boehme <markubo@amazon.de>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Shuah Khan <shuah@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/damon.h b/include/linux/damon.h
index be6b6e81e8ee1ca4dbf8ec26e0fe8ff0b5ef9397..f301bb53381c19d4ac6fc82e700c9a6d36a2df76 100644 (file)
--- a/include/linux/damon.h
+++ b/include/linux/damon.h
@@ -78,6 +78,7 @@ struct damon_target {
  * @DAMOS_PAGEOUT:     Call ``madvise()`` for the region with MADV_PAGEOUT.
  * @DAMOS_HUGEPAGE:    Call ``madvise()`` for the region with MADV_HUGEPAGE.
  * @DAMOS_NOHUGEPAGE:  Call ``madvise()`` for the region with MADV_NOHUGEPAGE.
+ * @DAMOS_STAT:                Do nothing but count the stat.
  */
 enum damos_action {
        DAMOS_WILLNEED,
@@ -85,6 +86,7 @@ enum damos_action {
        DAMOS_PAGEOUT,
        DAMOS_HUGEPAGE,
        DAMOS_NOHUGEPAGE,
+       DAMOS_STAT,             /* Do nothing but only record the stat */
 };
 
 /**
@@ -96,9 +98,13 @@ 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.
+ * @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.
  *
- * Note that both the minimums and the maximums are inclusive.
+ * 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.
  */
 struct damos {
        unsigned long min_sz_region;
@@ -108,6 +114,8 @@ struct damos {
        unsigned int min_age_region;
        unsigned int max_age_region;
        enum damos_action action;
+       unsigned long stat_count;
+       unsigned long stat_sz;
        struct list_head list;
 };
 

diff --git a/mm/damon/core.c b/mm/damon/core.c
index 0ed97b21cbb6e1ddac6b824958b472c7f8b2a9e1..2f6785737902dd98d326ba9d041e18318ec8a274 100644 (file)
--- a/mm/damon/core.c
+++ b/mm/damon/core.c
@@ -103,6 +103,8 @@ struct damos *damon_new_scheme(
        scheme->min_age_region = min_age_region;
        scheme->max_age_region = max_age_region;
        scheme->action = action;
+       scheme->stat_count = 0;
+       scheme->stat_sz = 0;
        INIT_LIST_HEAD(&scheme->list);
 
        return scheme;
@@ -544,9 +546,12 @@ 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)
                        c->primitive.apply_scheme(c, t, r, s);
-               r->age = 0;
+               if (s->action != DAMOS_STAT)
+                       r->age = 0;
        }
 }
 

diff --git a/mm/damon/dbgfs.c b/mm/damon/dbgfs.c
index 78b7a04490c57ef6b5461287804b80e232a65600..28d6abf277636be79eed404e1b700e5badc2cb5c 100644 (file)
--- a/mm/damon/dbgfs.c
+++ b/mm/damon/dbgfs.c
@@ -106,11 +106,11 @@ static ssize_t sprint_schemes(struct damon_ctx *c, char *buf, ssize_t len)
 
        damon_for_each_scheme(s, c) {
                rc = scnprintf(&buf[written], len - written,
-                               "%lu %lu %u %u %u %u %d\n",
+                               "%lu %lu %u %u %u %u %d %lu %lu\n",
                                s->min_sz_region, s->max_sz_region,
                                s->min_nr_accesses, s->max_nr_accesses,
                                s->min_age_region, s->max_age_region,
-                               s->action);
+                               s->action, s->stat_count, s->stat_sz);
                if (!rc)
                        return -ENOMEM;
 
@@ -159,6 +159,7 @@ static bool damos_action_valid(int action)
        case DAMOS_PAGEOUT:
        case DAMOS_HUGEPAGE:
        case DAMOS_NOHUGEPAGE:
+       case DAMOS_STAT:
                return true;
        default:
                return false;

diff --git a/mm/damon/vaddr.c b/mm/damon/vaddr.c
index 3e1c74d36bab7558d6fe13e70fdfbc279e948703..953c145b4f08a98a0a17815766c22c85034ebc05 100644 (file)
--- a/mm/damon/vaddr.c
+++ b/mm/damon/vaddr.c
@@ -705,6 +705,8 @@ int damon_va_apply_scheme(struct damon_ctx *ctx, struct damon_target *t,
        case DAMOS_NOHUGEPAGE:
                madv_action = MADV_NOHUGEPAGE;
                break;
+       case DAMOS_STAT:
+               return 0;
        default:
                pr_warn("Wrong action %d\n", scheme->action);
                return -EINVAL;