Re: [PATCH] drm/tests/drm_buddy: add alloc_contiguous test

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On 12/02/2024 08:23, Arunpravin Paneer Selvam wrote:
Hi Matthew,

Can I push this test case along with the bug fix patch.

Sure. Please go ahead.


Thanks,
Arun.

On 2/8/2024 8:06 PM, Matthew Auld wrote:
Sanity check DRM_BUDDY_CONTIGUOUS_ALLOCATION.

References: https://gitlab.freedesktop.org/drm/amd/-/issues/3097
Signed-off-by: Matthew Auld <matthew.auld@xxxxxxxxx>
Cc: Arunpravin Paneer Selvam <Arunpravin.PaneerSelvam@xxxxxxx>
Cc: Limonciello <mario.limonciello@xxxxxxx>
Cc: Christian König <christian.koenig@xxxxxxx>
---
  drivers/gpu/drm/tests/drm_buddy_test.c | 89 ++++++++++++++++++++++++++
  1 file changed, 89 insertions(+)

diff --git a/drivers/gpu/drm/tests/drm_buddy_test.c b/drivers/gpu/drm/tests/drm_buddy_test.c
index ea2af6bd9abe..4215d8b5fcf0 100644
--- a/drivers/gpu/drm/tests/drm_buddy_test.c
+++ b/drivers/gpu/drm/tests/drm_buddy_test.c
@@ -8,6 +8,7 @@
  #include <linux/prime_numbers.h>
  #include <linux/sched/signal.h>
+#include <linux/sizes.h>
  #include <drm/drm_buddy.h>
@@ -18,6 +19,93 @@ static inline u64 get_size(int order, u64 chunk_size)
      return (1 << order) * chunk_size;
  }
+static void drm_test_buddy_alloc_contiguous(struct kunit *test)
+{
+    u64 mm_size, ps = SZ_4K, i, n_pages, total;
+    struct drm_buddy_block *block;
+    struct drm_buddy mm;
+    LIST_HEAD(left);
+    LIST_HEAD(middle);
+    LIST_HEAD(right);
+    LIST_HEAD(allocated);
+
+    mm_size = 16 * 3 * SZ_4K;
+
+    KUNIT_EXPECT_FALSE(test, drm_buddy_init(&mm, mm_size, ps));
+
+    /*
+     * Idea is to fragment the address space by alternating block
+     * allocations between three different lists; one for left, middle and
+     * right. We can then free a list to simulate fragmentation. In
+     * particular we want to exercise the DRM_BUDDY_CONTIGUOUS_ALLOCATION,
+     * including the try_harder path.
+     */
+
+    i = 0;
+    n_pages = mm_size / ps;
+    do {
+        struct list_head *list;
+        int slot = i % 3;
+
+        if (slot == 0)
+            list = &left;
+        else if (slot == 1)
+            list = &middle;
+        else
+            list = &right;
+        KUNIT_ASSERT_FALSE_MSG(test,
+                       drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                                  ps, ps, list, 0),
+                       "buddy_alloc hit an error size=%d\n",
+                       ps);
+    } while (++i < n_pages);
+
+    KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                               3 * ps, ps, &allocated,
+                               DRM_BUDDY_CONTIGUOUS_ALLOCATION),
+                   "buddy_alloc didn't error size=%d\n", 3 * ps);
+
+    drm_buddy_free_list(&mm, &middle);
+    KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                               3 * ps, ps, &allocated,
+                               DRM_BUDDY_CONTIGUOUS_ALLOCATION),
+                   "buddy_alloc didn't error size=%llu\n", 3 * ps);
+    KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                               2 * ps, ps, &allocated,
+                               DRM_BUDDY_CONTIGUOUS_ALLOCATION),
+                   "buddy_alloc didn't error size=%llu\n", 2 * ps);
+
+    drm_buddy_free_list(&mm, &right);
+    KUNIT_ASSERT_TRUE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                               3 * ps, ps, &allocated,
+                               DRM_BUDDY_CONTIGUOUS_ALLOCATION),
+                   "buddy_alloc didn't error size=%llu\n", 3 * ps);
+    /*
+     * At this point we should have enough contiguous space for 2 blocks, +     * however they are never buddies (since we freed middle and right) so
+     * will require the try_harder logic to find them.
+     */
+    KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                               2 * ps, ps, &allocated,
+                               DRM_BUDDY_CONTIGUOUS_ALLOCATION),
+                   "buddy_alloc hit an error size=%d\n", 2 * ps);
+
+    drm_buddy_free_list(&mm, &left);
+    KUNIT_ASSERT_FALSE_MSG(test, drm_buddy_alloc_blocks(&mm, 0, mm_size,
+                               3 * ps, ps, &allocated,
+                               DRM_BUDDY_CONTIGUOUS_ALLOCATION),
+                   "buddy_alloc hit an error size=%d\n", 3 * ps);
+
+    total = 0;
+    list_for_each_entry(block, &allocated, link)
+        total += drm_buddy_block_size(&mm, block);
+
+    KUNIT_ASSERT_EQ(test, total, ps * 2 + ps * 3);
+
+    drm_buddy_free_list(&mm, &allocated);
+    drm_buddy_fini(&mm);
+}
+
  static void drm_test_buddy_alloc_pathological(struct kunit *test)
  {
      u64 mm_size, size, start = 0;
@@ -280,6 +368,7 @@ static struct kunit_case drm_buddy_tests[] = {
      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),
      {}
  };




[Index of Archives]     [Linux DRI Users]     [Linux Intel Graphics]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]
  Powered by Linux