[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();
	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();
	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 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++) {
		t = damon_new_target();
		damon_add_target(ctx, t);
	}

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