[PATCH] mm/damon/tests/core-kunit: test damon_nr_accesses_mvsum()

[PATCH] mm/damon/tests/core-kunit: test damon_nr_accesses_mvsum()

[Song Hu]

damon_nr_accesses_mvsum() wraps damon_mvsum() with the monitoring
intervals of the context to compute the pseudo moving sum of a region's
access frequency, with a special case for when the whole aggregation
window remains. damon_mvsum() itself is already covered by
damon_test_mvsum(), but the wrapper is not.

Add a table-driven KUnit test that exercises the full-window-remaining
boundary (with both reset and not-yet-reset nr_accesses), partially
elapsed windows, and the no-window-remaining case.

Signed-off-by: Song Hu <husong@kylinos.cn>
---
 mm/damon/tests/core-kunit.h | 49 +++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
index 0124f83b39b8..8c030282a638 100644
--- a/mm/damon/tests/core-kunit.h
+++ b/mm/damon/tests/core-kunit.h
@@ -683,6 +683,54 @@ static void damon_test_mvsum(struct kunit *test)
 	}
 }
 
+/*
+ * Test damon_nr_accesses_mvsum(), which wraps damon_mvsum() with the monitoring
+ * intervals of the context.  With a sample interval of 1 and an aggregation
+ * interval of 10, an aggregation window is 10 sample intervals long.  Each row
+ * below specifies the passed sample intervals, the next aggregation time in
+ * sample intervals, the current and last nr_accesses of a region, and the
+ * expected return value.
+ */
+static void damon_test_nr_accesses_mvsum(struct kunit *test)
+{
+	unsigned long input_expects[] = {
+		/* passed, next_aggr, nr_accesses, last_nr_accesses, expect */
+		0, 10, 5, 3, 3,		/* bp=10000: unreset nr_accesses ignored */
+		0, 10, 0, 7, 7,		/* bp=10000: reset nr_accesses */
+		5, 10, 3, 10, 8,	/* bp=5000: half window left */
+		8, 10, 3, 10, 5,	/* bp=2000: 20% window left */
+		10, 10, 42, 49, 42,	/* bp=0: no window left */
+	};
+	struct damon_ctx *c = damon_new_ctx();
+	struct damon_region *r;
+	int i;
+
+	if (!c)
+		kunit_skip(test, "ctx alloc fail");
+
+	r = damon_new_region(0, 4096);
+	if (!r) {
+		damon_destroy_ctx(c);
+		kunit_skip(test, "region alloc fail");
+	}
+
+	c->attrs.sample_interval = 1;
+	c->attrs.aggr_interval = 10;
+
+	for (i = 0; i < ARRAY_SIZE(input_expects); i += 5) {
+		c->passed_sample_intervals = input_expects[i];
+		c->next_aggregation_sis = input_expects[i + 1];
+		r->nr_accesses = input_expects[i + 2];
+		r->last_nr_accesses = input_expects[i + 3];
+
+		KUNIT_EXPECT_EQ(test, (unsigned int)input_expects[i + 4],
+				damon_nr_accesses_mvsum(r, c));
+	}
+
+	damon_free_region(r);
+	damon_destroy_ctx(c);
+}
+
 static void damos_test_new_filter(struct kunit *test)
 {
 	struct damos_filter *filter;
@@ -1576,6 +1624,7 @@ static struct kunit_case damon_test_cases[] = {
 	KUNIT_CASE(damon_test_update_monitoring_result),
 	KUNIT_CASE(damon_test_set_attrs),
 	KUNIT_CASE(damon_test_mvsum),
+	KUNIT_CASE(damon_test_nr_accesses_mvsum),
 	KUNIT_CASE(damos_test_new_filter),
 	KUNIT_CASE(damos_test_commit_quota_goal),
 	KUNIT_CASE(damos_test_commit_quota_goals),
-- 
2.43.0

Re: [PATCH] mm/damon/tests/core-kunit: test damon_nr_accesses_mvsum()

[SJ Park]

On Fri, 10 Jul 2026 12:15:30 +0800 Song Hu <husong@kylinos.cn> wrote:

> damon_nr_accesses_mvsum() wraps damon_mvsum() with the monitoring
> intervals of the context to compute the pseudo moving sum of a region's
> access frequency, with a special case for when the whole aggregation
> window remains. damon_mvsum() itself is already covered by
> damon_test_mvsum(), but the wrapper is not.
> 
> Add a table-driven KUnit test that exercises the full-window-remaining
> boundary (with both reset and not-yet-reset nr_accesses), partially
> elapsed windows, and the no-window-remaining case.

Nice!  Thank you!

> 
> Signed-off-by: Song Hu <husong@kylinos.cn>
> ---
>  mm/damon/tests/core-kunit.h | 49 +++++++++++++++++++++++++++++++++++++
>  1 file changed, 49 insertions(+)
> 
> diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
> index 0124f83b39b8..8c030282a638 100644
> --- a/mm/damon/tests/core-kunit.h
> +++ b/mm/damon/tests/core-kunit.h
> @@ -683,6 +683,54 @@ static void damon_test_mvsum(struct kunit *test)
>  	}
>  }
>  
> +/*
> + * Test damon_nr_accesses_mvsum(), which wraps damon_mvsum() with the monitoring

Please wrap lines [1] for 80 columns limit.

> + * intervals of the context.  With a sample interval of 1 and an aggregation
> + * interval of 10, an aggregation window is 10 sample intervals long.  Each row
> + * below specifies the passed sample intervals, the next aggregation time in
> + * sample intervals, the current and last nr_accesses of a region, and the
> + * expected return value.
> + */
> +static void damon_test_nr_accesses_mvsum(struct kunit *test)
> +{
> +	unsigned long input_expects[] = {
> +		/* passed, next_aggr, nr_accesses, last_nr_accesses, expect */
> +		0, 10, 5, 3, 3,		/* bp=10000: unreset nr_accesses ignored */

I was bit confused what 'bp' means.  Can we just drop 'bp=...:' part from the
comment?

Also, let's keep the 80 columns limit.

[...]

Other than those, looks good to me!

[1] https://docs.kernel.org/process/coding-style.html#breaking-long-lines-and-strings


Thanks,
SJ

Re: [PATCH] mm/damon/tests/core-kunit: test damon_nr_accesses_mvsum()

[Song Hu]

于 2026年7月10日 GMT+08:00 22:02:37，SJ Park <sj@kernel.org> 写道：
>On Fri, 10 Jul 2026 12:15:30 +0800 Song Hu <husong@kylinos.cn> wrote:
>
>> damon_nr_accesses_mvsum() wraps damon_mvsum() with the monitoring
>> intervals of the context to compute the pseudo moving sum of a region's
>> access frequency, with a special case for when the whole aggregation
>> window remains. damon_mvsum() itself is already covered by
>> damon_test_mvsum(), but the wrapper is not.
>> 
>> Add a table-driven KUnit test that exercises the full-window-remaining
>> boundary (with both reset and not-yet-reset nr_accesses), partially
>> elapsed windows, and the no-window-remaining case.
>
>Nice!  Thank you!
>
>> 
>> Signed-off-by: Song Hu <husong@kylinos.cn>
>> ---
>>  mm/damon/tests/core-kunit.h | 49 +++++++++++++++++++++++++++++++++++++
>>  1 file changed, 49 insertions(+)
>> 
>> diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
>> index 0124f83b39b8..8c030282a638 100644
>> --- a/mm/damon/tests/core-kunit.h
>> +++ b/mm/damon/tests/core-kunit.h
>> @@ -683,6 +683,54 @@ static void damon_test_mvsum(struct kunit *test)
>>  	}
>>  }
>>  
>> +/*
>> + * Test damon_nr_accesses_mvsum(), which wraps damon_mvsum() with the monitoring
>
>Please wrap lines [1] for 80 columns limit.

Hi SJ,

Thanks for your review. This was my mistake, and I will resolve it in the next patch version.

>
>> + * intervals of the context.  With a sample interval of 1 and an aggregation
>> + * interval of 10, an aggregation window is 10 sample intervals long.  Each row
>> + * below specifies the passed sample intervals, the next aggregation time in
>> + * sample intervals, the current and last nr_accesses of a region, and the
>> + * expected return value.
>> + */
>> +static void damon_test_nr_accesses_mvsum(struct kunit *test)
>> +{
>> +	unsigned long input_expects[] = {
>> +		/* passed, next_aggr, nr_accesses, last_nr_accesses, expect */
>> +		0, 10, 5, 3, 3,		/* bp=10000: unreset nr_accesses ignored */
>
>I was bit confused what 'bp' means.  Can we just drop 'bp=...:' part from the
>comment?
>

This explanation is just my personal guess. I will delete all uncertain content in the revised patch.

Thanks,
Song

>Also, let's keep the 80 columns limit.
>
>[...]
>
>Other than those, looks good to me!
>
>[1] https://docs.kernel.org/process/coding-style.html#breaking-long-lines-and-strings
>
>
>Thanks,
>SJ