Re: [PATCH 4/6] drm/tests/drm_buddy: add alloc_range_bias test

[Arunpravin Paneer Selvam <arunpravin.paneerselvam@amd.com>]

[-- Attachment #1: Type: text/plain, Size: 9470 bytes --]

Reviewed-by: Arunpravin Paneer Selvam <Arunpravin.PaneerSelvam@amd.com>



On 2/15/2024 11:14 PM, Matthew Auld wrote:
> Sanity check range bias with DRM_BUDDY_RANGE_ALLOCATION.
>
> Signed-off-by: Matthew Auld<matthew.auld@intel.com>
> Cc: Arunpravin Paneer Selvam<Arunpravin.PaneerSelvam@amd.com>
> Cc: Christian König<christian.koenig@amd.com>
> ---
>   drivers/gpu/drm/tests/drm_buddy_test.c | 218 +++++++++++++++++++++++++
>   1 file changed, 218 insertions(+)
>
> diff --git a/drivers/gpu/drm/tests/drm_buddy_test.c b/drivers/gpu/drm/tests/drm_buddy_test.c
> index edacc1adb28f..3d4b29686132 100644
> --- a/drivers/gpu/drm/tests/drm_buddy_test.c
> +++ b/drivers/gpu/drm/tests/drm_buddy_test.c
> @@ -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);
> +		u64 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 {
> +		u64 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 {
> +			u64 old_bias_start = bias_start;
> +			u64 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,
>   };
>   

[-- Attachment #2: Type: text/html, Size: 10093 bytes --]