Commit c7070332 authored by Matthew Auld's avatar Matthew Auld Committed by Christian König
Browse files

drm/tests/drm_buddy: add alloc_range_bias test 



Sanity check range bias with DRM_BUDDY_RANGE_ALLOCATION.

v2:
  - Be consistent with u32 here.

Signed-off-by: default avatarMatthew Auld <matthew.auld@intel.com>
Cc: Arunpravin Paneer Selvam <Arunpravin.PaneerSelvam@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Reviewed-by: default avatarArunpravin Paneer Selvam <Arunpravin.PaneerSelvam@amd.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240219121851.25774-6-matthew.auld@intel.com


Signed-off-by: default avatarChristian König <christian.koenig@amd.com>
parent 2986314a

drivers/gpu/drm/tests/drm_buddy_test.c

+218 −0
Original line number Diff line number Diff line
@@ -14,11 +14,216 @@ 


#include "../lib/drm_random.h"



static unsigned int random_seed;



static inline u64 get_size(int order, u64 chunk_size)

{

	return (1 << order) * chunk_size;

}



static void drm_test_buddy_alloc_range_bias(struct kunit *test)

{

	u32 mm_size, ps, bias_size, bias_start, bias_end, bias_rem;

	DRM_RND_STATE(prng, random_seed);

	unsigned int i, count, *order;

	struct drm_buddy mm;

	LIST_HEAD(allocated);



	bias_size = SZ_1M;

	ps = roundup_pow_of_two(prandom_u32_state(&prng) % bias_size);

	ps = max(SZ_4K, ps);

	mm_size = (SZ_8M-1) & ~(ps-1); /* Multiple roots */



	kunit_info(test, "mm_size=%u, ps=%u\n", mm_size, ps);



	KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),

			       "buddy_init failed\n");



	count = mm_size / bias_size;

	order = drm_random_order(count, &prng);

	KUNIT_EXPECT_TRUE(test, order);



	/*

	 * Idea is to split the address space into uniform bias ranges, and then

	 * in some random order allocate within each bias, using various

	 * patterns within. This should detect if allocations leak out from a

	 * given bias, for example.

	 */



	for (i = 0; i < count; i++) {

		LIST_HEAD(tmp);

		u32 size;



		bias_start = order[i] * bias_size;

		bias_end = bias_start + bias_size;

		bias_rem = bias_size;



		/* internal round_up too big */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start,

							     bias_end, bias_size + ps, bias_size,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start, bias_end, bias_size, bias_size);



		/* size too big */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start,

							     bias_end, bias_size + ps, ps,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start, bias_end, bias_size + ps, ps);



		/* bias range too small for size */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start + ps,

							     bias_end, bias_size, ps,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start + ps, bias_end, bias_size, ps);



		/* bias misaligned */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start + ps,

							     bias_end - ps,

							     bias_size >> 1, bias_size >> 1,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc h didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start + ps, bias_end - ps, bias_size >> 1, bias_size >> 1);



		/* single big page */

		KUNIT_ASSERT_FALSE_MSG(test,

				       drm_buddy_alloc_blocks(&mm, bias_start,

							      bias_end, bias_size, bias_size,

							      &tmp,

							      DRM_BUDDY_RANGE_ALLOCATION),

				       "buddy_alloc i failed with bias(%x-%x), size=%u, ps=%u\n",

				       bias_start, bias_end, bias_size, bias_size);

		drm_buddy_free_list(&mm, &tmp);



		/* single page with internal round_up */

		KUNIT_ASSERT_FALSE_MSG(test,

				       drm_buddy_alloc_blocks(&mm, bias_start,

							      bias_end, ps, bias_size,

							      &tmp,

							      DRM_BUDDY_RANGE_ALLOCATION),

				       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

				       bias_start, bias_end, ps, bias_size);

		drm_buddy_free_list(&mm, &tmp);



		/* random size within */

		size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps);

		if (size)

			KUNIT_ASSERT_FALSE_MSG(test,

					       drm_buddy_alloc_blocks(&mm, bias_start,

								      bias_end, size, ps,

								      &tmp,

								      DRM_BUDDY_RANGE_ALLOCATION),

					       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

					       bias_start, bias_end, size, ps);



		bias_rem -= size;

		/* too big for current avail */

		KUNIT_ASSERT_TRUE_MSG(test,

				      drm_buddy_alloc_blocks(&mm, bias_start,

							     bias_end, bias_rem + ps, ps,

							     &allocated,

							     DRM_BUDDY_RANGE_ALLOCATION),

				      "buddy_alloc didn't fail with bias(%x-%x), size=%u, ps=%u\n",

				      bias_start, bias_end, bias_rem + ps, ps);



		if (bias_rem) {

			/* random fill of the remainder */

			size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps);

			size = max(size, ps);



			KUNIT_ASSERT_FALSE_MSG(test,

					       drm_buddy_alloc_blocks(&mm, bias_start,

								      bias_end, size, ps,

								      &allocated,

								      DRM_BUDDY_RANGE_ALLOCATION),

					       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

					       bias_start, bias_end, size, ps);

			/*

			 * Intentionally allow some space to be left

			 * unallocated, and ideally not always on the bias

			 * boundaries.

			 */

			drm_buddy_free_list(&mm, &tmp);

		} else {

			list_splice_tail(&tmp, &allocated);

		}

	}



	kfree(order);

	drm_buddy_free_list(&mm, &allocated);

	drm_buddy_fini(&mm);



	/*

	 * Something more free-form. Idea is to pick a random starting bias

	 * range within the address space and then start filling it up. Also

	 * randomly grow the bias range in both directions as we go along. This

	 * should give us bias start/end which is not always uniform like above,

	 * and in some cases will require the allocator to jump over already

	 * allocated nodes in the middle of the address space.

	 */



	KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_init(&mm, mm_size, ps),

			       "buddy_init failed\n");



	bias_start = round_up(prandom_u32_state(&prng) % (mm_size - ps), ps);

	bias_end = round_up(bias_start + prandom_u32_state(&prng) % (mm_size - bias_start), ps);

	bias_end = max(bias_end, bias_start + ps);

	bias_rem = bias_end - bias_start;



	do {

		u32 size = max(round_up(prandom_u32_state(&prng) % bias_rem, ps), ps);



		KUNIT_ASSERT_FALSE_MSG(test,

				       drm_buddy_alloc_blocks(&mm, bias_start,

							      bias_end, size, ps,

							      &allocated,

							      DRM_BUDDY_RANGE_ALLOCATION),

				       "buddy_alloc failed with bias(%x-%x), size=%u, ps=%u\n",

				       bias_start, bias_end, size);

		bias_rem -= size;



		/*

		 * Try to randomly grow the bias range in both directions, or

		 * only one, or perhaps don't grow at all.

		 */

		do {

			u32 old_bias_start = bias_start;

			u32 old_bias_end = bias_end;



			if (bias_start)

				bias_start -= round_up(prandom_u32_state(&prng) % bias_start, ps);

			if (bias_end != mm_size)

				bias_end += round_up(prandom_u32_state(&prng) % (mm_size - bias_end), ps);



			bias_rem += old_bias_start - bias_start;

			bias_rem += bias_end - old_bias_end;

		} while (!bias_rem && (bias_start || bias_end != mm_size));

	} while (bias_rem);



	KUNIT_ASSERT_EQ(test, bias_start, 0);

	KUNIT_ASSERT_EQ(test, bias_end, mm_size);

	KUNIT_ASSERT_TRUE_MSG(test,

			      drm_buddy_alloc_blocks(&mm, bias_start, bias_end,

						     ps, ps,

						     &allocated,

						     DRM_BUDDY_RANGE_ALLOCATION),

			      "buddy_alloc passed with bias(%x-%x), size=%u\n",

			      bias_start, bias_end, ps);



	drm_buddy_free_list(&mm, &allocated);

	drm_buddy_fini(&mm);

}



static void drm_test_buddy_alloc_contiguous(struct kunit *test)

{

	u32 mm_size, ps = SZ_4K, i, n_pages, total;
@@ -363,17 +568,30 @@ static void drm_test_buddy_alloc_limit(struct kunit *test) 
	drm_buddy_fini(&mm);

}



static int drm_buddy_suite_init(struct kunit_suite *suite)

{

	while (!random_seed)

		random_seed = get_random_u32();



	kunit_info(suite, "Testing DRM buddy manager, with random_seed=0x%x\n",

		   random_seed);



	return 0;

}



static struct kunit_case drm_buddy_tests[] = {

	KUNIT_CASE(drm_test_buddy_alloc_limit),

	KUNIT_CASE(drm_test_buddy_alloc_optimistic),

	KUNIT_CASE(drm_test_buddy_alloc_pessimistic),

	KUNIT_CASE(drm_test_buddy_alloc_pathological),

	KUNIT_CASE(drm_test_buddy_alloc_contiguous),

	KUNIT_CASE(drm_test_buddy_alloc_range_bias),

	{}

};



static struct kunit_suite drm_buddy_test_suite = {

	.name = "drm_buddy",

	.suite_init = drm_buddy_suite_init,

	.test_cases = drm_buddy_tests,

};