[linux-block.git] / mm / damon / core-test.h

/* 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 <sjpark@amazon.de>
 */

#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;

	r = damon_new_region(1, 2);
	KUNIT_EXPECT_EQ(test, 1ul, r->ar.start);
	KUNIT_EXPECT_EQ(test, 2ul, r->ar.end);
	KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses);

	t = damon_new_target(42);
	KUNIT_EXPECT_EQ(test, 0u, damon_nr_regions(t));

	damon_add_region(r, t);
	KUNIT_EXPECT_EQ(test, 1u, damon_nr_regions(t));

	damon_del_region(r, t);
	KUNIT_EXPECT_EQ(test, 0u, damon_nr_regions(t));

	damon_free_target(t);
}

static unsigned int nr_damon_targets(struct damon_ctx *ctx)
{
	struct damon_target *t;
	unsigned int nr_targets = 0;

	damon_for_each_target(t, ctx)
		nr_targets++;

	return nr_targets;
}

static void damon_test_target(struct kunit *test)
{
	struct damon_ctx *c = damon_new_ctx();
	struct damon_target *t;

	t = damon_new_target(42);
	KUNIT_EXPECT_EQ(test, 42ul, t->id);
	KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c));

	damon_add_target(c, t);
	KUNIT_EXPECT_EQ(test, 1u, nr_damon_targets(c));

	damon_destroy_target(t);
	KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c));

	damon_destroy_ctx(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 target_ids[] = {1, 2, 3};
	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;

	damon_set_targets(ctx, target_ids, 3);

	it = 0;
	damon_for_each_target(t, ctx) {
		for (ir = 0; ir < 3; ir++) {
			r = damon_new_region(saddr[it][ir], eaddr[it][ir]);
			r->nr_accesses = accesses[it][ir];
			damon_add_region(r, t);
		}
		it++;
	}
	kdamond_reset_aggregated(ctx);
	it = 0;
	damon_for_each_target(t, ctx) {
		ir = 0;
		/* '->nr_accesses' should be zeroed */
		damon_for_each_region(r, t) {
			KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses);
			ir++;
		}
		/* regions should be preserved */
		KUNIT_EXPECT_EQ(test, 3, ir);
		it++;
	}
	/* targets also should be preserved */
	KUNIT_EXPECT_EQ(test, 3, it);

	damon_destroy_ctx(ctx);
}

static void damon_test_split_at(struct kunit *test)
{
	struct damon_ctx *c = damon_new_ctx();
	struct damon_target *t;
	struct damon_region *r;

	t = damon_new_target(42);
	r = damon_new_region(0, 100);
	damon_add_region(r, t);
	damon_split_region_at(c, t, r, 25);
	KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
	KUNIT_EXPECT_EQ(test, r->ar.end, 25ul);

	r = damon_next_region(r);
	KUNIT_EXPECT_EQ(test, r->ar.start, 25ul);
	KUNIT_EXPECT_EQ(test, r->ar.end, 100ul);

	damon_free_target(t);
	damon_destroy_ctx(c);
}

static void damon_test_merge_two(struct kunit *test)
{
	struct damon_target *t;
	struct damon_region *r, *r2, *r3;
	int i;

	t = damon_new_target(42);
	r = damon_new_region(0, 100);
	r->nr_accesses = 10;
	damon_add_region(r, t);
	r2 = damon_new_region(100, 300);
	r2->nr_accesses = 20;
	damon_add_region(r2, t);

	damon_merge_two_regions(t, r, r2);
	KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
	KUNIT_EXPECT_EQ(test, r->ar.end, 300ul);
	KUNIT_EXPECT_EQ(test, r->nr_accesses, 16u);

	i = 0;
	damon_for_each_region(r3, t) {
		KUNIT_EXPECT_PTR_EQ(test, r, r3);
		i++;
	}
	KUNIT_EXPECT_EQ(test, i, 1);

	damon_free_target(t);
}

static struct damon_region *__nth_region_of(struct damon_target *t, int idx)
{
	struct damon_region *r;
	unsigned int i = 0;

	damon_for_each_region(r, t) {
		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;

	t = damon_new_target(42);
	for (i = 0; i < ARRAY_SIZE(sa); i++) {
		r = damon_new_region(sa[i], ea[i]);
		r->nr_accesses = nrs[i];
		damon_add_region(r, t);
	}

	damon_merge_regions_of(t, 9, 9999);
	/* 0-112, 114-130, 130-156, 156-170 */
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 5u);
	for (i = 0; i < 5; i++) {
		r = __nth_region_of(t, i);
		KUNIT_EXPECT_EQ(test, r->ar.start, saddrs[i]);
		KUNIT_EXPECT_EQ(test, r->ar.end, eaddrs[i]);
	}
	damon_free_target(t);
}

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;

	t = damon_new_target(42);
	r = damon_new_region(0, 22);
	damon_add_region(r, t);
	damon_split_regions_of(c, t, 2);
	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u);
	damon_free_target(t);

	t = damon_new_target(42);
	r = damon_new_region(0, 220);
	damon_add_region(r, t);
	damon_split_regions_of(c, t, 4);
	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u);
	damon_free_target(t);
	damon_destroy_ctx(c);
}

static struct kunit_case damon_test_cases[] = {
	KUNIT_CASE(damon_test_target),
	KUNIT_CASE(damon_test_regions),
	KUNIT_CASE(damon_test_aggregate),
	KUNIT_CASE(damon_test_split_at),
	KUNIT_CASE(damon_test_merge_two),
	KUNIT_CASE(damon_test_merge_regions_of),
	KUNIT_CASE(damon_test_split_regions_of),
	{},
};

static struct kunit_suite damon_test_suite = {
	.name = "damon",
	.test_cases = damon_test_cases,
};
kunit_test_suite(damon_test_suite);

#endif /* _DAMON_CORE_TEST_H */

#endif	/* CONFIG_DAMON_KUNIT_TEST */
Commit	Line	Data
17ccae8b SP	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	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
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
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
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
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
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);
2e014660	222	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u);
17ccae8b SP	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);
2e014660	229	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u);
17ccae8b SP	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 */