[PATCH 0/3] mm/damon/tests: add KUnit coverage for age_ms filters

[PATCH 0/3] mm/damon/tests: add KUnit coverage for age_ms filters

[Jason Angelov]

The DAMON core tests do not cover DAMOS_FILTER_TYPE_AGE_MS. Add tests for
committing valid and invalid age ranges, identifying the filter as
core-handled, and matching ages at and outside the range boundaries.

Region age is counted in aggregation intervals, but age_ms filter bounds
are in milliseconds. The interval-change test checks age rescaling and
filter matching after both increasing and decreasing the aggregation
interval.

Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>
---
Jason Angelov (3):
      mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_test_commit_filter()
      mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_filter_for_ops()
      mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS interval changes

 mm/damon/tests/core-kunit.h | 107 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
---
base-commit: daed51c9105158768a3949395135aa6e0a04bb7e
change-id: 20261112-test-age-ms-filter-9953843e7204

Best regards,
-- 
Jason Angelov <jasonangelov@ucla.edu>

[PATCH 1/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_test_commit_filter()

[Jason Angelov]

add kunit tests that commit DAMOS core filter type
DAMOS_FILTER_TYPE_AGE_MS.

Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>
---
 mm/damon/tests/core-kunit.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
index a5ca4bfe2f0d..0eb5dcdba0ae 100644
--- a/mm/damon/tests/core-kunit.h
+++ b/mm/damon/tests/core-kunit.h
@@ -1271,6 +1271,10 @@ static void damos_test_commit_filter_for(struct kunit *test,
 	KUNIT_EXPECT_EQ(test, dst->matching, src->matching);
 	KUNIT_EXPECT_EQ(test, dst->allow, src->allow);
 	switch (src->type) {
+	case DAMOS_FILTER_TYPE_AGE_MS:
+		KUNIT_EXPECT_EQ(test, dst->range_min, src->range_min);
+		KUNIT_EXPECT_EQ(test, dst->range_max, src->range_max);
+		break;
 	case DAMOS_FILTER_TYPE_MEMCG:
 		KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);
 		break;
@@ -1304,6 +1308,22 @@ static void damos_test_commit_filter(struct kunit *test)
 		.allow = false,
 	};
 
+	damos_test_commit_filter_for(test, &dst,
+			&(struct damos_filter){
+			.type = DAMOS_FILTER_TYPE_AGE_MS,
+			.matching = true,
+			.allow = true,
+			.range_min = 36,
+			.range_max = 14
+			}, true);
+	damos_test_commit_filter_for(test, &dst,
+			&(struct damos_filter){
+			.type = DAMOS_FILTER_TYPE_AGE_MS,
+			.matching = true,
+			.allow = true,
+			.range_min = 14,
+			.range_max = 36
+			}, false);
 	damos_test_commit_filter_for(test, &dst,
 			&(struct damos_filter){
 			.type = DAMOS_FILTER_TYPE_ANON,

-- 
2.53.0

[PATCH 2/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_filter_for_ops()

[Jason Angelov]

DAMOS_FILTER_TYPE_AGE_MS is core filter, not ops filter.
add kunit test covering this rejection.

Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>
---
 mm/damon/tests/core-kunit.h | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
index 0eb5dcdba0ae..fb84d30a712d 100644
--- a/mm/damon/tests/core-kunit.h
+++ b/mm/damon/tests/core-kunit.h
@@ -1832,6 +1832,11 @@ static void damon_test_valid_probe_params(struct kunit *test)
 	damon_destroy_ctx(ctx);
 }
 
+static void damos_test_age_ms_filter_is_core(struct kunit *test)
+{
+	KUNIT_EXPECT_FALSE(test, damos_filter_for_ops(DAMOS_FILTER_TYPE_AGE_MS));
+}
+
 static void damos_test_filter_out(struct kunit *test)
 {
 	struct damon_target *t;
@@ -2593,6 +2598,7 @@ static struct kunit_case damon_test_cases[] = {
 	KUNIT_CASE(damon_test_commit_ctx),
 	KUNIT_CASE(damon_test_commit_ctx_keeps_quota),
 	KUNIT_CASE(damon_test_valid_probe_params),
+	KUNIT_CASE(damos_test_age_ms_filter_is_core),
 	KUNIT_CASE(damos_test_filter_out),
 	KUNIT_CASE(damos_test_apply_scheme_filtered_sz),
 	KUNIT_CASE(damos_test_apply_scheme_filter_sz_unchanged),

-- 
2.53.0

[PATCH 3/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS interval changes

[Jason Angelov]

DAMOS_FILTER_TYPE_AGE_MS defines an inclusive range for age in
milliseconds to filter for target regions.
Aggregation interval can be changed by users or intervals
auto-tuning features.

Add a kunit test for each:

- convert region age to milliseconds, correct behavior at boundaries
for defined filter range
- DAMOS_FILTER_TYPE_AGE_MS filter keeps correct behavior even when
aggregation interval changes

Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>
---
 mm/damon/tests/core-kunit.h | 81 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
index fb84d30a712d..6de7c2531702 100644
--- a/mm/damon/tests/core-kunit.h
+++ b/mm/damon/tests/core-kunit.h
@@ -1837,6 +1837,86 @@ static void damos_test_age_ms_filter_is_core(struct kunit *test)
 	KUNIT_EXPECT_FALSE(test, damos_filter_for_ops(DAMOS_FILTER_TYPE_AGE_MS));
 }
 
+static void damos_test_age_ms_filter_interval_changes(struct kunit *test)
+{
+	/* Filter window: 200-400 ms.  Start: 100 ms interval, age 0. */
+	struct damos_filter filter = {
+		.type = DAMOS_FILTER_TYPE_AGE_MS,
+		.matching = true,
+		.range_min = 200,
+		.range_max = 400,
+	};
+	struct damon_attrs attrs = {
+		.sample_interval = 5000,
+		.aggr_interval = 100000,
+		.min_nr_regions = 3,
+		.max_nr_regions = 3,
+	};
+	struct damon_ctx *ctx;
+	struct damon_target *t;
+	struct damon_region *r;
+	int err;
+
+	ctx = damon_new_ctx();
+	if (!ctx)
+		kunit_skip(test, "ctx alloc fail");
+	t = damon_new_target();
+	if (!t) {
+		damon_destroy_ctx(ctx);
+		kunit_skip(test, "target alloc fail");
+	}
+	damon_add_target(ctx, t);
+	r = damon_new_region(0, DAMON_MIN_REGION_SZ);
+	if (!r) {
+		damon_destroy_ctx(ctx);
+		kunit_skip(test, "region alloc fail");
+	}
+	damon_add_region(r, t);
+	KUNIT_EXPECT_EQ(test, damon_set_attrs(ctx, &attrs), 0);
+
+	/* below window: age 1 = 100 ms */
+	r->age = 1;
+	KUNIT_EXPECT_FALSE(test, damos_filter_match(ctx, t, r, &filter,
+			ctx->min_region_sz, &err));
+
+	/* inside window: age 2 = 200 ms */
+	r->age = 2;
+	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
+			ctx->min_region_sz, &err));
+
+	/*
+	 * change aggregation interval 100 -> 200 ms:
+	 * inside window: age rescaled 2 -> 1, still 200 ms
+	 */
+	attrs.aggr_interval = 200000;
+	KUNIT_EXPECT_EQ(test, damon_set_attrs(ctx, &attrs), 0);
+	KUNIT_EXPECT_EQ(test, r->age, 1u);
+	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
+			ctx->min_region_sz, &err));
+
+	/* inside window: age 2 = 400 ms. */
+	r->age = 2;
+	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
+			ctx->min_region_sz, &err));
+
+	/*
+	 * change aggregation interval 200 -> 50 ms:
+	 * inside window: age rescaled 2 -> 8, still 400 ms.
+	 */
+	attrs.aggr_interval = 50000;
+	KUNIT_EXPECT_EQ(test, damon_set_attrs(ctx, &attrs), 0);
+	KUNIT_EXPECT_EQ(test, r->age, 8u);
+	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
+			ctx->min_region_sz, &err));
+
+	/* above window: age 9 = 450 ms. */
+	r->age = 9;
+	KUNIT_EXPECT_FALSE(test, damos_filter_match(ctx, t, r, &filter,
+			ctx->min_region_sz, &err));
+
+	damon_destroy_ctx(ctx);
+}
+
 static void damos_test_filter_out(struct kunit *test)
 {
 	struct damon_target *t;
@@ -2599,6 +2679,7 @@ static struct kunit_case damon_test_cases[] = {
 	KUNIT_CASE(damon_test_commit_ctx_keeps_quota),
 	KUNIT_CASE(damon_test_valid_probe_params),
 	KUNIT_CASE(damos_test_age_ms_filter_is_core),
+	KUNIT_CASE(damos_test_age_ms_filter_interval_changes),
 	KUNIT_CASE(damos_test_filter_out),
 	KUNIT_CASE(damos_test_apply_scheme_filtered_sz),
 	KUNIT_CASE(damos_test_apply_scheme_filter_sz_unchanged),

-- 
2.53.0

Re: [PATCH 3/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS interval changes

[sashiko-bot]

> DAMOS_FILTER_TYPE_AGE_MS defines an inclusive range for age in
> milliseconds to filter for target regions.
> Aggregation interval can be changed by users or intervals
> auto-tuning features.
> 
> Add a kunit test for each:
> 
> - convert region age to milliseconds, correct behavior at boundaries
> for defined filter range
> - DAMOS_FILTER_TYPE_AGE_MS filter keeps correct behavior even when
> aggregation interval changes
> 
> Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261113-test-age-ms-filter-v1-0-b99eab2f71bb@ucla.edu?part=3

Re: [PATCH 2/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_filter_for_ops()

[sashiko-bot]

> DAMOS_FILTER_TYPE_AGE_MS is core filter, not ops filter.
> add kunit test covering this rejection.
> 
> Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261113-test-age-ms-filter-v1-0-b99eab2f71bb@ucla.edu?part=2

Re: [PATCH 1/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_test_commit_filter()

[sashiko-bot]

> add kunit tests that commit DAMOS core filter type
> DAMOS_FILTER_TYPE_AGE_MS.
> 
> Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261113-test-age-ms-filter-v1-0-b99eab2f71bb@ucla.edu?part=1

Re: [PATCH 1/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_test_commit_filter()

[SJ Park]

On Fri, 13 Nov 2026 07:58:55 -0800 Jason Angelov <jasonangelov@ucla.edu> wrote:

> add kunit tests that commit DAMOS core filter type
> DAMOS_FILTER_TYPE_AGE_MS.

s/add/Add/ ?

> 
> Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>

Other than the above,

Reviewed-by: SJ Park <sj@kernel.org>


Thanks,
SJ

[...]

Re: [PATCH 2/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS in damos_filter_for_ops()

[SJ Park]

On Fri, 13 Nov 2026 07:58:56 -0800 Jason Angelov <jasonangelov@ucla.edu> wrote:

> DAMOS_FILTER_TYPE_AGE_MS is core filter, not ops filter.
> add kunit test covering this rejection.

s/add/Add/ ?

> 
> Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>
> ---
>  mm/damon/tests/core-kunit.h | 6 ++++++
>  1 file changed, 6 insertions(+)
> 
> diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
> index 0eb5dcdba0ae..fb84d30a712d 100644
> --- a/mm/damon/tests/core-kunit.h
> +++ b/mm/damon/tests/core-kunit.h
> @@ -1832,6 +1832,11 @@ static void damon_test_valid_probe_params(struct kunit *test)
>  	damon_destroy_ctx(ctx);
>  }
>  
> +static void damos_test_age_ms_filter_is_core(struct kunit *test)
> +{
> +	KUNIT_EXPECT_FALSE(test, damos_filter_for_ops(DAMOS_FILTER_TYPE_AGE_MS));

Let's wrap the line for the 80 columns per line rule.

Other than above two trivial things,

Reviewed-by: SJ Park <sj@kernel.org>


Thanks,
SJ

[...]

Re: [PATCH 3/3] mm/damon/tests/core-kunit: test DAMOS_FILTER_TYPE_AGE_MS interval changes

[SJ Park]

On Fri, 13 Nov 2026 07:58:57 -0800 Jason Angelov <jasonangelov@ucla.edu> wrote:

> DAMOS_FILTER_TYPE_AGE_MS defines an inclusive range for age in
> milliseconds to filter for target regions.
> Aggregation interval can be changed by users or intervals
> auto-tuning features.

Let's put the second sentence in the line of the end of the first sentence.  In
the way, we can save one line.

> 
> Add a kunit test for each:
> 
> - convert region age to milliseconds, correct behavior at boundaries
> for defined filter range

Let's add two spaces indentation, to make the bullet point lists easier to
read.

> - DAMOS_FILTER_TYPE_AGE_MS filter keeps correct behavior even when
> aggregation interval changes

Ditto.

> 
> Signed-off-by: Jason Angelov <jasonangelov@ucla.edu>
> ---
>  mm/damon/tests/core-kunit.h | 81 +++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 81 insertions(+)
> 
> diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h
> index fb84d30a712d..6de7c2531702 100644
> --- a/mm/damon/tests/core-kunit.h
> +++ b/mm/damon/tests/core-kunit.h
> @@ -1837,6 +1837,86 @@ static void damos_test_age_ms_filter_is_core(struct kunit *test)
>  	KUNIT_EXPECT_FALSE(test, damos_filter_for_ops(DAMOS_FILTER_TYPE_AGE_MS));
>  }
>  
> +static void damos_test_age_ms_filter_interval_changes(struct kunit *test)
> +{
> +	/* Filter window: 200-400 ms.  Start: 100 ms interval, age 0. */

This looks like not a complete sentence for readers but a personal note.
Please make the comment more human-readable or just drop.

> +	struct damos_filter filter = {
> +		.type = DAMOS_FILTER_TYPE_AGE_MS,
> +		.matching = true,
> +		.range_min = 200,
> +		.range_max = 400,
> +	};
> +	struct damon_attrs attrs = {
> +		.sample_interval = 5000,
> +		.aggr_interval = 100000,
> +		.min_nr_regions = 3,
> +		.max_nr_regions = 3,
> +	};
> +	struct damon_ctx *ctx;
> +	struct damon_target *t;
> +	struct damon_region *r;
> +	int err;
> +
> +	ctx = damon_new_ctx();
> +	if (!ctx)
> +		kunit_skip(test, "ctx alloc fail");
> +	t = damon_new_target();
> +	if (!t) {
> +		damon_destroy_ctx(ctx);
> +		kunit_skip(test, "target alloc fail");
> +	}
> +	damon_add_target(ctx, t);
> +	r = damon_new_region(0, DAMON_MIN_REGION_SZ);
> +	if (!r) {
> +		damon_destroy_ctx(ctx);
> +		kunit_skip(test, "region alloc fail");
> +	}
> +	damon_add_region(r, t);
> +	KUNIT_EXPECT_EQ(test, damon_set_attrs(ctx, &attrs), 0);

Why test damon_set_attrs() in this test?

> +
> +	/* below window: age 1 = 100 ms */

What the "window" means?  Filter's range_{min,max}?  This again feels like a
personal note rather than somewhat useful for other code readers.  Please make
the comment more human readable or just drop.

> +	r->age = 1;
> +	KUNIT_EXPECT_FALSE(test, damos_filter_match(ctx, t, r, &filter,
> +			ctx->min_region_sz, &err));
> +
> +	/* inside window: age 2 = 200 ms */

Ditto.  Same for all comments in this function.

> +	r->age = 2;
> +	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
> +			ctx->min_region_sz, &err));
> +
> +	/*
> +	 * change aggregation interval 100 -> 200 ms:
> +	 * inside window: age rescaled 2 -> 1, still 200 ms
> +	 */
> +	attrs.aggr_interval = 200000;
> +	KUNIT_EXPECT_EQ(test, damon_set_attrs(ctx, &attrs), 0);

Why test damon_set_attrs() in this test?

> +	KUNIT_EXPECT_EQ(test, r->age, 1u);
> +	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
> +			ctx->min_region_sz, &err));
> +
> +	/* inside window: age 2 = 400 ms. */
> +	r->age = 2;
> +	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
> +			ctx->min_region_sz, &err));
> +
> +	/*
> +	 * change aggregation interval 200 -> 50 ms:
> +	 * inside window: age rescaled 2 -> 8, still 400 ms.
> +	 */
> +	attrs.aggr_interval = 50000;
> +	KUNIT_EXPECT_EQ(test, damon_set_attrs(ctx, &attrs), 0);
> +	KUNIT_EXPECT_EQ(test, r->age, 8u);
> +	KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter,
> +			ctx->min_region_sz, &err));
> +
> +	/* above window: age 9 = 450 ms. */
> +	r->age = 9;
> +	KUNIT_EXPECT_FALSE(test, damos_filter_match(ctx, t, r, &filter,
> +			ctx->min_region_sz, &err));
> +
> +	damon_destroy_ctx(ctx);
> +}
> +
>  static void damos_test_filter_out(struct kunit *test)
>  {
>  	struct damon_target *t;
> @@ -2599,6 +2679,7 @@ static struct kunit_case damon_test_cases[] = {
>  	KUNIT_CASE(damon_test_commit_ctx_keeps_quota),
>  	KUNIT_CASE(damon_test_valid_probe_params),
>  	KUNIT_CASE(damos_test_age_ms_filter_is_core),
> +	KUNIT_CASE(damos_test_age_ms_filter_interval_changes),
>  	KUNIT_CASE(damos_test_filter_out),
>  	KUNIT_CASE(damos_test_apply_scheme_filtered_sz),
>  	KUNIT_CASE(damos_test_apply_scheme_filter_sz_unchanged),
> 
> -- 
> 2.53.0
> 
> 


Thanks,
SJ

Re: [PATCH 0/3] mm/damon/tests: add KUnit coverage for age_ms filters

[SJ Park]

Hi Jason,

On Fri, 13 Nov 2026 07:58:54 -0800 Jason Angelov <jasonangelov@ucla.edu> wrote:

> The DAMON core tests do not cover DAMOS_FILTER_TYPE_AGE_MS. Add tests for
> committing valid and invalid age ranges, identifying the filter as
> core-handled, and matching ages at and outside the range boundaries.
> 
> Region age is counted in aggregation intervals, but age_ms filter bounds
> are in milliseconds. The interval-change test checks age rescaling and
> filter matching after both increasing and decreasing the aggregation
> interval.

Thank you for this series.  I show only small nits in the first two patches.
But the third one looks a revisioning is needed.  Could you please address my
comments?


Thanks,
SJ

[...]