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 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 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 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 */ 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 for (it = 0; it < 3; it++) { 90 t = damon_new_target(target_ids[it]); 91 damon_add_target(ctx, t); 92 } 93 94 it = 0; 95 damon_for_each_target(t, ctx) { 96 for (ir = 0; ir < 3; ir++) { 97 r = damon_new_region(saddr[it][ir], eaddr[it][ir]); 98 r->nr_accesses = accesses[it][ir]; 99 damon_add_region(r, t); 100 } 101 it++; 102 } 103 kdamond_reset_aggregated(ctx); 104 it = 0; 105 damon_for_each_target(t, ctx) { 106 ir = 0; 107 /* '->nr_accesses' should be zeroed */ 108 damon_for_each_region(r, t) { 109 KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses); 110 ir++; 111 } 112 /* regions should be preserved */ 113 KUNIT_EXPECT_EQ(test, 3, ir); 114 it++; 115 } 116 /* targets also should be preserved */ 117 KUNIT_EXPECT_EQ(test, 3, it); 118 119 damon_destroy_ctx(ctx); 120 } 121 122 static void damon_test_split_at(struct kunit *test) 123 { 124 struct damon_ctx *c = damon_new_ctx(); 125 struct damon_target *t; 126 struct damon_region *r; 127 128 t = damon_new_target(42); 129 r = damon_new_region(0, 100); 130 damon_add_region(r, t); 131 damon_split_region_at(c, t, r, 25); 132 KUNIT_EXPECT_EQ(test, r->ar.start, 0ul); 133 KUNIT_EXPECT_EQ(test, r->ar.end, 25ul); 134 135 r = damon_next_region(r); 136 KUNIT_EXPECT_EQ(test, r->ar.start, 25ul); 137 KUNIT_EXPECT_EQ(test, r->ar.end, 100ul); 138 139 damon_free_target(t); 140 damon_destroy_ctx(c); 141 } 142 143 static void damon_test_merge_two(struct kunit *test) 144 { 145 struct damon_target *t; 146 struct damon_region *r, *r2, *r3; 147 int i; 148 149 t = damon_new_target(42); 150 r = damon_new_region(0, 100); 151 r->nr_accesses = 10; 152 damon_add_region(r, t); 153 r2 = damon_new_region(100, 300); 154 r2->nr_accesses = 20; 155 damon_add_region(r2, t); 156 157 damon_merge_two_regions(t, r, r2); 158 KUNIT_EXPECT_EQ(test, r->ar.start, 0ul); 159 KUNIT_EXPECT_EQ(test, r->ar.end, 300ul); 160 KUNIT_EXPECT_EQ(test, r->nr_accesses, 16u); 161 162 i = 0; 163 damon_for_each_region(r3, t) { 164 KUNIT_EXPECT_PTR_EQ(test, r, r3); 165 i++; 166 } 167 KUNIT_EXPECT_EQ(test, i, 1); 168 169 damon_free_target(t); 170 } 171 172 static struct damon_region *__nth_region_of(struct damon_target *t, int idx) 173 { 174 struct damon_region *r; 175 unsigned int i = 0; 176 177 damon_for_each_region(r, t) { 178 if (i++ == idx) 179 return r; 180 } 181 182 return NULL; 183 } 184 185 static void damon_test_merge_regions_of(struct kunit *test) 186 { 187 struct damon_target *t; 188 struct damon_region *r; 189 unsigned long sa[] = {0, 100, 114, 122, 130, 156, 170, 184}; 190 unsigned long ea[] = {100, 112, 122, 130, 156, 170, 184, 230}; 191 unsigned int nrs[] = {0, 0, 10, 10, 20, 30, 1, 2}; 192 193 unsigned long saddrs[] = {0, 114, 130, 156, 170}; 194 unsigned long eaddrs[] = {112, 130, 156, 170, 230}; 195 int i; 196 197 t = damon_new_target(42); 198 for (i = 0; i < ARRAY_SIZE(sa); i++) { 199 r = damon_new_region(sa[i], ea[i]); 200 r->nr_accesses = nrs[i]; 201 damon_add_region(r, t); 202 } 203 204 damon_merge_regions_of(t, 9, 9999); 205 /* 0-112, 114-130, 130-156, 156-170 */ 206 KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 5u); 207 for (i = 0; i < 5; i++) { 208 r = __nth_region_of(t, i); 209 KUNIT_EXPECT_EQ(test, r->ar.start, saddrs[i]); 210 KUNIT_EXPECT_EQ(test, r->ar.end, eaddrs[i]); 211 } 212 damon_free_target(t); 213 } 214 215 static void damon_test_split_regions_of(struct kunit *test) 216 { 217 struct damon_ctx *c = damon_new_ctx(); 218 struct damon_target *t; 219 struct damon_region *r; 220 221 t = damon_new_target(42); 222 r = damon_new_region(0, 22); 223 damon_add_region(r, t); 224 damon_split_regions_of(c, t, 2); 225 KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u); 226 damon_free_target(t); 227 228 t = damon_new_target(42); 229 r = damon_new_region(0, 220); 230 damon_add_region(r, t); 231 damon_split_regions_of(c, t, 4); 232 KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u); 233 damon_free_target(t); 234 damon_destroy_ctx(c); 235 } 236 237 static struct kunit_case damon_test_cases[] = { 238 KUNIT_CASE(damon_test_target), 239 KUNIT_CASE(damon_test_regions), 240 KUNIT_CASE(damon_test_aggregate), 241 KUNIT_CASE(damon_test_split_at), 242 KUNIT_CASE(damon_test_merge_two), 243 KUNIT_CASE(damon_test_merge_regions_of), 244 KUNIT_CASE(damon_test_split_regions_of), 245 {}, 246 }; 247 248 static struct kunit_suite damon_test_suite = { 249 .name = "damon", 250 .test_cases = damon_test_cases, 251 }; 252 kunit_test_suite(damon_test_suite); 253 254 #endif /* _DAMON_CORE_TEST_H */ 255 256 #endif /* CONFIG_DAMON_KUNIT_TEST */ 257