1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Data Access Monitor Unit Tests
4 *
5 * Copyright 2019 Amazon.com, Inc. or its affiliates. All rights reserved.
6 *
7 * Author: SeongJae Park <sjpark@amazon.de>
8 */
9
10 #ifdef CONFIG_DAMON_KUNIT_TEST
11
12 #ifndef _DAMON_CORE_TEST_H
13 #define _DAMON_CORE_TEST_H
14
15 #include <kunit/test.h>
16
damon_test_regions(struct kunit * test)17 static void damon_test_regions(struct kunit *test)
18 {
19 struct damon_region *r;
20 struct damon_target *t;
21
22 r = damon_new_region(1, 2);
23 KUNIT_EXPECT_EQ(test, 1ul, r->ar.start);
24 KUNIT_EXPECT_EQ(test, 2ul, r->ar.end);
25 KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses);
26
27 t = damon_new_target(42);
28 KUNIT_EXPECT_EQ(test, 0u, damon_nr_regions(t));
29
30 damon_add_region(r, t);
31 KUNIT_EXPECT_EQ(test, 1u, damon_nr_regions(t));
32
33 damon_del_region(r, t);
34 KUNIT_EXPECT_EQ(test, 0u, damon_nr_regions(t));
35
36 damon_free_target(t);
37 }
38
nr_damon_targets(struct damon_ctx * ctx)39 static unsigned int nr_damon_targets(struct damon_ctx *ctx)
40 {
41 struct damon_target *t;
42 unsigned int nr_targets = 0;
43
44 damon_for_each_target(t, ctx)
45 nr_targets++;
46
47 return nr_targets;
48 }
49
damon_test_target(struct kunit * test)50 static void damon_test_target(struct kunit *test)
51 {
52 struct damon_ctx *c = damon_new_ctx();
53 struct damon_target *t;
54
55 t = damon_new_target(42);
56 KUNIT_EXPECT_EQ(test, 42ul, t->id);
57 KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c));
58
59 damon_add_target(c, t);
60 KUNIT_EXPECT_EQ(test, 1u, nr_damon_targets(c));
61
62 damon_destroy_target(t);
63 KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c));
64
65 damon_destroy_ctx(c);
66 }
67
68 /*
69 * Test kdamond_reset_aggregated()
70 *
71 * DAMON checks access to each region and aggregates this information as the
72 * access frequency of each region. In detail, it increases '->nr_accesses' of
73 * regions that an access has confirmed. 'kdamond_reset_aggregated()' flushes
74 * the aggregated information ('->nr_accesses' of each regions) to the result
75 * buffer. As a result of the flushing, the '->nr_accesses' of regions are
76 * initialized to zero.
77 */
damon_test_aggregate(struct kunit * test)78 static void damon_test_aggregate(struct kunit *test)
79 {
80 struct damon_ctx *ctx = damon_new_ctx();
81 unsigned long target_ids[] = {1, 2, 3};
82 unsigned long saddr[][3] = {{10, 20, 30}, {5, 42, 49}, {13, 33, 55} };
83 unsigned long eaddr[][3] = {{15, 27, 40}, {31, 45, 55}, {23, 44, 66} };
84 unsigned long accesses[][3] = {{42, 95, 84}, {10, 20, 30}, {0, 1, 2} };
85 struct damon_target *t;
86 struct damon_region *r;
87 int it, ir;
88
89 damon_set_targets(ctx, target_ids, 3);
90
91 it = 0;
92 damon_for_each_target(t, ctx) {
93 for (ir = 0; ir < 3; ir++) {
94 r = damon_new_region(saddr[it][ir], eaddr[it][ir]);
95 r->nr_accesses = accesses[it][ir];
96 damon_add_region(r, t);
97 }
98 it++;
99 }
100 kdamond_reset_aggregated(ctx);
101 it = 0;
102 damon_for_each_target(t, ctx) {
103 ir = 0;
104 /* '->nr_accesses' should be zeroed */
105 damon_for_each_region(r, t) {
106 KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses);
107 ir++;
108 }
109 /* regions should be preserved */
110 KUNIT_EXPECT_EQ(test, 3, ir);
111 it++;
112 }
113 /* targets also should be preserved */
114 KUNIT_EXPECT_EQ(test, 3, it);
115
116 damon_destroy_ctx(ctx);
117 }
118
damon_test_split_at(struct kunit * test)119 static void damon_test_split_at(struct kunit *test)
120 {
121 struct damon_ctx *c = damon_new_ctx();
122 struct damon_target *t;
123 struct damon_region *r;
124
125 t = damon_new_target(42);
126 r = damon_new_region(0, 100);
127 damon_add_region(r, t);
128 damon_split_region_at(c, t, r, 25);
129 KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
130 KUNIT_EXPECT_EQ(test, r->ar.end, 25ul);
131
132 r = damon_next_region(r);
133 KUNIT_EXPECT_EQ(test, r->ar.start, 25ul);
134 KUNIT_EXPECT_EQ(test, r->ar.end, 100ul);
135
136 damon_free_target(t);
137 damon_destroy_ctx(c);
138 }
139
damon_test_merge_two(struct kunit * test)140 static void damon_test_merge_two(struct kunit *test)
141 {
142 struct damon_target *t;
143 struct damon_region *r, *r2, *r3;
144 int i;
145
146 t = damon_new_target(42);
147 r = damon_new_region(0, 100);
148 r->nr_accesses = 10;
149 damon_add_region(r, t);
150 r2 = damon_new_region(100, 300);
151 r2->nr_accesses = 20;
152 damon_add_region(r2, t);
153
154 damon_merge_two_regions(t, r, r2);
155 KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
156 KUNIT_EXPECT_EQ(test, r->ar.end, 300ul);
157 KUNIT_EXPECT_EQ(test, r->nr_accesses, 16u);
158
159 i = 0;
160 damon_for_each_region(r3, t) {
161 KUNIT_EXPECT_PTR_EQ(test, r, r3);
162 i++;
163 }
164 KUNIT_EXPECT_EQ(test, i, 1);
165
166 damon_free_target(t);
167 }
168
__nth_region_of(struct damon_target * t,int idx)169 static struct damon_region *__nth_region_of(struct damon_target *t, int idx)
170 {
171 struct damon_region *r;
172 unsigned int i = 0;
173
174 damon_for_each_region(r, t) {
175 if (i++ == idx)
176 return r;
177 }
178
179 return NULL;
180 }
181
damon_test_merge_regions_of(struct kunit * test)182 static void damon_test_merge_regions_of(struct kunit *test)
183 {
184 struct damon_target *t;
185 struct damon_region *r;
186 unsigned long sa[] = {0, 100, 114, 122, 130, 156, 170, 184};
187 unsigned long ea[] = {100, 112, 122, 130, 156, 170, 184, 230};
188 unsigned int nrs[] = {0, 0, 10, 10, 20, 30, 1, 2};
189
190 unsigned long saddrs[] = {0, 114, 130, 156, 170};
191 unsigned long eaddrs[] = {112, 130, 156, 170, 230};
192 int i;
193
194 t = damon_new_target(42);
195 for (i = 0; i < ARRAY_SIZE(sa); i++) {
196 r = damon_new_region(sa[i], ea[i]);
197 r->nr_accesses = nrs[i];
198 damon_add_region(r, t);
199 }
200
201 damon_merge_regions_of(t, 9, 9999);
202 /* 0-112, 114-130, 130-156, 156-170 */
203 KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 5u);
204 for (i = 0; i < 5; i++) {
205 r = __nth_region_of(t, i);
206 KUNIT_EXPECT_EQ(test, r->ar.start, saddrs[i]);
207 KUNIT_EXPECT_EQ(test, r->ar.end, eaddrs[i]);
208 }
209 damon_free_target(t);
210 }
211
damon_test_split_regions_of(struct kunit * test)212 static void damon_test_split_regions_of(struct kunit *test)
213 {
214 struct damon_ctx *c = damon_new_ctx();
215 struct damon_target *t;
216 struct damon_region *r;
217
218 t = damon_new_target(42);
219 r = damon_new_region(0, 22);
220 damon_add_region(r, t);
221 damon_split_regions_of(c, t, 2);
222 KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u);
223 damon_free_target(t);
224
225 t = damon_new_target(42);
226 r = damon_new_region(0, 220);
227 damon_add_region(r, t);
228 damon_split_regions_of(c, t, 4);
229 KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u);
230 damon_free_target(t);
231 damon_destroy_ctx(c);
232 }
233
234 static struct kunit_case damon_test_cases[] = {
235 KUNIT_CASE(damon_test_target),
236 KUNIT_CASE(damon_test_regions),
237 KUNIT_CASE(damon_test_aggregate),
238 KUNIT_CASE(damon_test_split_at),
239 KUNIT_CASE(damon_test_merge_two),
240 KUNIT_CASE(damon_test_merge_regions_of),
241 KUNIT_CASE(damon_test_split_regions_of),
242 {},
243 };
244
245 static struct kunit_suite damon_test_suite = {
246 .name = "damon",
247 .test_cases = damon_test_cases,
248 };
249 kunit_test_suite(damon_test_suite);
250
251 #endif /* _DAMON_CORE_TEST_H */
252
253 #endif /* CONFIG_DAMON_KUNIT_TEST */
254