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 --- mm/damon/tests/core-kunit.h | 66 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h index 156f74832c40..3b2b745b8546 100644 --- a/mm/damon/tests/core-kunit.h +++ b/mm/damon/tests/core-kunit.h @@ -1838,6 +1838,71 @@ static void damos_test_age_ms_filter_is_core(struct kunit *test) damos_filter_for_ops(DAMOS_FILTER_TYPE_AGE_MS)); } +static void damos_test_age_ms_filter_interval_changes(struct kunit *test) +{ + struct damos_filter filter = { + .type = DAMOS_FILTER_TYPE_AGE_MS, + .matching = true, + .range_min = 200, + .range_max = 400, + }; + 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); + ctx->attrs.aggr_interval = 100000; + + /* An age of 100 ms is below the 200 ms lower bound. */ + r->age = 1; + KUNIT_EXPECT_FALSE(test, damos_filter_match(ctx, t, r, &filter, + ctx->min_region_sz, &err)); + + /* An age of 200 ms matches the inclusive lower bound. */ + r->age = 2; + KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter, + ctx->min_region_sz, &err)); + + /* At a 200 ms interval, age 1 matches the lower bound. */ + ctx->attrs.aggr_interval = 200000; + r->age = 1; + KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter, + ctx->min_region_sz, &err)); + + /* An age of 400 ms matches the inclusive upper bound. */ + r->age = 2; + KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter, + ctx->min_region_sz, &err)); + + /* At a 50 ms interval, age 8 matches the upper bound. */ + ctx->attrs.aggr_interval = 50000; + r->age = 8; + KUNIT_EXPECT_TRUE(test, damos_filter_match(ctx, t, r, &filter, + ctx->min_region_sz, &err)); + + /* An age of 450 ms exceeds the 400 ms upper bound. */ + 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; @@ -2600,6 +2665,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