Add kunit tests that commit DAMOS core filter type DAMOS_FILTER_TYPE_AGE_MS. Reviewed-by: SJ Park Signed-off-by: Jason Angelov --- 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 DAMOS_FILTER_TYPE_AGE_MS is core filter, not ops filter. Add kunit test covering this rejection. Reviewed-by: SJ Park Signed-off-by: Jason Angelov --- mm/damon/tests/core-kunit.h | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/mm/damon/tests/core-kunit.h b/mm/damon/tests/core-kunit.h index 0eb5dcdba0ae..156f74832c40 100644 --- a/mm/damon/tests/core-kunit.h +++ b/mm/damon/tests/core-kunit.h @@ -1832,6 +1832,12 @@ 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 +2599,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 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