/* SPDX-License-Identifier: GPL-2.0 */ /* * Data Access Monitor Unit Tests * * Copyright 2019 Amazon . com , Inc . or its affiliates . All rights reserved . * * Author : SeongJae Park < sj @ kernel . org > #ifdef CONFIG_DAMON_KUNIT_TEST#ifndef _DAMON_CORE_TEST_H#define _DAMON_CORE_TEST_H#include <kunit/test.h>static void damon_test_regions(struct kunit *test)struct damon_region *r;struct damon_target *t;1 , 2 );1 ul, r->ar.start);2 ul, r->ar.end);0 u, r->nr_accesses);0 u, damon_nr_regions(t));1 u, damon_nr_regions(t));0 u, damon_nr_regions(t));static unsigned int nr_damon_targets(struct damon_ctx *ctx)struct damon_target *t;unsigned int nr_targets = 0 ;return nr_targets;static void damon_test_target(struct kunit *test)struct damon_ctx *c = damon_new_ctx();struct damon_target *t;0 u, nr_damon_targets(c));1 u, nr_damon_targets(c));0 u, nr_damon_targets(c));/* * Test kdamond_reset_aggregated ( ) * * DAMON checks access to each region and aggregates this information as the * access frequency of each region . In detail , it increases ' - > nr_accesses ' of * regions that an access has confirmed . ' kdamond_reset_aggregated ( ) ' flushes * the aggregated information ( ' - > nr_accesses ' of each regions ) to the result * buffer . As a result of the flushing , the ' - > nr_accesses ' of regions are * initialized to zero . static void damon_test_aggregate(struct kunit *test)struct damon_ctx *ctx = damon_new_ctx();unsigned long saddr[][3 ] = {{10 , 20 , 30 }, {5 , 42 , 49 }, {13 , 33 , 55 } };unsigned long eaddr[][3 ] = {{15 , 27 , 40 }, {31 , 45 , 55 }, {23 , 44 , 66 } };unsigned long accesses[][3 ] = {{42 , 95 , 84 }, {10 , 20 , 30 }, {0 , 1 , 2 } };struct damon_target *t;struct damon_region *r;int it, ir;for (it = 0 ; it < 3 ; it++) {0 ;for (ir = 0 ; ir < 3 ; ir++) {10000 ;0 ;0 ;/* '->nr_accesses' should be zeroed */ 0 u, r->nr_accesses);/* regions should be preserved */ 3 , ir);/* targets also should be preserved */ 3 , it);static void damon_test_split_at(struct kunit *test)struct damon_ctx *c = damon_new_ctx();struct damon_target *t;struct damon_region *r, *r_new;0 , 100 );420000 ;42 ;15 ;25 );0 ul);25 ul);25 ul);100 ul);static void damon_test_merge_two(struct kunit *test)struct damon_target *t;struct damon_region *r, *r2, *r3;int i;0 , 100 );10 ;100000 ;100 , 300 );20 ;200000 ;0 ul);300 ul);16 u);0 ;1 );static struct damon_region *__nth_region_of(struct damon_target *t, int idx)struct damon_region *r;unsigned int i = 0 ;if (i++ == idx)return r;return NULL;static void damon_test_merge_regions_of(struct kunit *test)struct damon_target *t;struct damon_region *r;unsigned long sa[] = {0 , 100 , 114 , 122 , 130 , 156 , 170 , 184 };unsigned long ea[] = {100 , 112 , 122 , 130 , 156 , 170 , 184 , 230 };unsigned int nrs[] = {0 , 0 , 10 , 10 , 20 , 30 , 1 , 2 };unsigned long saddrs[] = {0 , 114 , 130 , 156 , 170 };unsigned long eaddrs[] = {112 , 130 , 156 , 170 , 230 };int i;for (i = 0 ; i < ARRAY_SIZE(sa); i++) {10000 ;9 , 9999 );/* 0-112, 114-130, 130-156, 156-170 */ 5 u);for (i = 0 ; i < 5 ; i++) {static void damon_test_split_regions_of(struct kunit *test)struct damon_ctx *c = damon_new_ctx();struct damon_target *t;struct damon_region *r;0 , 22 );2 );2 u);0 , 220 );4 );4 u);static void damon_test_ops_registration(struct kunit *test)struct damon_ctx *c = damon_new_ctx();struct damon_operations ops = {.id = DAMON_OPS_VADDR}, bak;bool need_cleanup = false ;/* DAMON_OPS_VADDR is registered only if CONFIG_DAMON_VADDR is set */ if (!damon_is_registered_ops(DAMON_OPS_VADDR)) {0 );true ;/* DAMON_OPS_VADDR is ensured to be registered */ 0 );/* Double-registration is prohibited */ /* Unknown ops id cannot be registered */ /* Registration should success after unregistration */ struct damon_operations){};0 );/* Check double-registration failure again */ if (need_cleanup) {struct damon_operations){};static void damon_test_set_regions(struct kunit *test)struct damon_target *t = damon_new_target();struct damon_region *r1 = damon_new_region(4 , 16 );struct damon_region *r2 = damon_new_region(24 , 32 );struct damon_addr_range range = {.start = 8 , .end = 28 };unsigned long expects[] = {8 , 16 , 16 , 24 , 24 , 28 };int expect_idx = 0 ;struct damon_region *r;1 );3 );static void damon_test_nr_accesses_to_accesses_bp(struct kunit *test)struct damon_attrs attrs = {10 ,unsigned long )UINT_MAX + 1 ) * 10 /* * In some cases such as 32 bit architectures where UINT_MAX is * ULONG_MAX , attrs . aggr_interval becomes zero . Calling * damon_nr_accesses_to_accesses_bp ( ) in the case will cause * divide - by - zero . Such case is prohibited in normal execution since * the caution is documented on the comment for the function , and * damon_update_monitoring_results ( ) does the check . Skip the test in * the case . if (!attrs.aggr_interval)"aggr_interval is zero." );123 , &attrs), 0 );static void damon_test_update_monitoring_result(struct kunit *test)struct damon_attrs old_attrs = {10 , .aggr_interval = 1000 ,};struct damon_attrs new_attrs;struct damon_region *r = damon_new_region(3 , 7 );15 ;150000 ;20 ;struct damon_attrs){100 , .aggr_interval = 10000 ,};false );15 );2 );struct damon_attrs){1 , .aggr_interval = 1000 };false );150 );2 );struct damon_attrs){1 , .aggr_interval = 100 };false );150 );20 );static void damon_test_set_attrs(struct kunit *test)struct damon_ctx *c = damon_new_ctx();struct damon_attrs valid_attrs = {10 , .max_nr_regions = 1000 ,5000 , .aggr_interval = 100000 ,};struct damon_attrs invalid_attrs;0 );1 ;9 ;4999 ;static void damon_test_moving_sum(struct kunit *test)unsigned int mvsum = 50000 , nomvsum = 50000 , len_window = 10 ;unsigned int new_values[] = {10000 , 0 , 10000 , 0 , 0 , 0 , 10000 , 0 , 0 , 0 };unsigned int expects[] = {55000 , 50000 , 55000 , 50000 , 45000 , 40000 ,45000 , 40000 , 35000 , 30000 };int i;for (i = 0 ; i < ARRAY_SIZE(new_values); i++) {static void damos_test_new_filter(struct kunit *test)struct damos_filter *filter;true , false );true );static void damos_test_filter_out(struct kunit *test)struct damon_target *t;struct damon_region *r, *r2;struct damos_filter *f;true , false );struct damon_addr_range){2 , .end = DAMON_MIN_REGION * 6 };3 , DAMON_MIN_REGION * 5 );/* region in the range */ 1 );/* region before the range */ 1 ;2 ;1 );/* region after the range */ 6 ;8 ;1 );/* region started before the range */ 1 ;4 ;/* filter should have split the region */ 1 );2 );2 );2 );4 );/* region started in the range */ 2 ;8 ;/* filter should have split the region */ 2 );6 );2 );6 );8 );static void damon_test_feed_loop_next_input(struct kunit *test)unsigned long last_input = 900000 , current_score = 200 ;/* * If current score is lower than the goal , which is always 10 , 000 * ( read the comment on damon_feed_loop_next_input ( ) ' s comment ) , next * input should be higher than the last input . /* * If current score is higher than the goal , next input should be lower * than the last input . 250000000 ;/* * The next input depends on the distance between the current score and * the goal 200 ),2000 ));static void damon_test_set_filters_default_reject(struct kunit *test)struct damos scheme;struct damos_filter *target_filter, *anon_filter;/* * No filter is installed . Allow by default on both core and ops layer * filtering stages , since there are no filters at all . false );false );true , true );/* * A core - handled allow - filter is installed . * Rejct by default on core layer filtering stage due to the last * core - layer - filter ' s behavior . * Allow by default on ops layer filtering stage due to the absence of * ops layer filters . true );false );false ;/* * A core - handled reject - filter is installed . * Allow by default on core layer filtering stage due to the last * core - layer - filter ' s behavior . * Allow by default on ops layer filtering stage due to the absence of * ops layer filters . false );false );true , true );/* * A core - handled reject - filter and ops - handled allow - filter are installed . * Allow by default on core layer filtering stage due to the existence * of the ops - handled filter . * Reject by default on ops layer filtering stage due to the last * ops - layer - filter ' s behavior . false );true );true ;/* * A core - handled allow - filter and ops - handled allow - filter are * installed . * Allow by default on core layer filtering stage due to the existence * of the ops - handled filter . * Reject by default on ops layer filtering stage due to the last * ops - layer - filter ' s behavior . false );true );static struct kunit_case damon_test_cases[] = {static struct kunit_suite damon_test_suite = {"damon" ,#endif /* _DAMON_CORE_TEST_H */ #endif /* CONFIG_DAMON_KUNIT_TEST */
Messung V0.5 in Prozent C=96 H=95 G=95
¤ Dauer der Verarbeitung: 0.13 Sekunden
(vorverarbeitet am 2026-09-28)
¤ *© Formatika GbR, Deutschland
