drm/mm: add ig_frag selftest
diff mbox series

Message ID 20200528130556.53275-1-nirmoy.das@amd.com
State New
Headers show
Series
  • drm/mm: add ig_frag selftest
Related show

Commit Message

Nirmoy Das May 28, 2020, 1:05 p.m. UTC
This patch introduces fragmentation in the address range
and measures time taken by 10k insertions for each modes.

ig_frag() will fail if one of the mode takes more than 1 sec.

Output:
<snip>
[   37.326723] drm_mm: igt_sanitycheck - ok!
[   37.326727] igt_debug 0x0000000000000000-0x0000000000000200: 512: free
[   37.326728] igt_debug 0x0000000000000200-0x0000000000000600: 1024: used
[   37.326728] igt_debug 0x0000000000000600-0x0000000000000a00: 1024: free
[   37.326729] igt_debug 0x0000000000000a00-0x0000000000000e00: 1024: used
[   37.326730] igt_debug 0x0000000000000e00-0x0000000000001000: 512: free
[   37.326730] igt_debug total: 4096, used 2048 free 2048
[   56.040064] drm_mm: best fragmented insert took 504 msecs
[   56.082184] drm_mm: bottom-up fragmented insert took 40 msecs
[   56.102255] drm_mm: top-down fragmented insert took 20 msecs
[   56.107177] drm_mm: evict fragmented insert took 4 msecs
<snip>

Signed-off-by: Nirmoy Das <nirmoy.das@amd.com>
---
 drivers/gpu/drm/selftests/drm_mm_selftests.h |  1 +
 drivers/gpu/drm/selftests/test-drm_mm.c      | 59 ++++++++++++++++++++
 2 files changed, 60 insertions(+)

Comments

Nirmoy May 29, 2020, 8:20 a.m. UTC | #1
On 5/28/20 6:04 PM, Chris Wilson wrote:
> Quoting Nirmoy Das (2020-05-28 14:05:56)
>> This patch introduces fragmentation in the address range
>> and measures time taken by 10k insertions for each modes.
>>
>> ig_frag() will fail if one of the mode takes more than 1 sec.
>>
>> Output:
>> <snip>
>> [   37.326723] drm_mm: igt_sanitycheck - ok!
>> [   37.326727] igt_debug 0x0000000000000000-0x0000000000000200: 512: free
>> [   37.326728] igt_debug 0x0000000000000200-0x0000000000000600: 1024: used
>> [   37.326728] igt_debug 0x0000000000000600-0x0000000000000a00: 1024: free
>> [   37.326729] igt_debug 0x0000000000000a00-0x0000000000000e00: 1024: used
>> [   37.326730] igt_debug 0x0000000000000e00-0x0000000000001000: 512: free
>> [   37.326730] igt_debug total: 4096, used 2048 free 2048
>> [   56.040064] drm_mm: best fragmented insert took 504 msecs
>> [   56.082184] drm_mm: bottom-up fragmented insert took 40 msecs
>> [   56.102255] drm_mm: top-down fragmented insert took 20 msecs
>> [   56.107177] drm_mm: evict fragmented insert took 4 msecs
>> <snip>
>>
>> Signed-off-by: Nirmoy Das <nirmoy.das@amd.com>
>> ---
>>   drivers/gpu/drm/selftests/drm_mm_selftests.h |  1 +
>>   drivers/gpu/drm/selftests/test-drm_mm.c      | 59 ++++++++++++++++++++
>>   2 files changed, 60 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/selftests/drm_mm_selftests.h b/drivers/gpu/drm/selftests/drm_mm_selftests.h
>> index 6b943ea1c57d..8c87c964176b 100644
>> --- a/drivers/gpu/drm/selftests/drm_mm_selftests.h
>> +++ b/drivers/gpu/drm/selftests/drm_mm_selftests.h
>> @@ -14,6 +14,7 @@ selftest(insert, igt_insert)
>>   selftest(replace, igt_replace)
>>   selftest(insert_range, igt_insert_range)
>>   selftest(align, igt_align)
>> +selftest(frag, igt_frag)
>>   selftest(align32, igt_align32)
>>   selftest(align64, igt_align64)
>>   selftest(evict, igt_evict)
>> diff --git a/drivers/gpu/drm/selftests/test-drm_mm.c b/drivers/gpu/drm/selftests/test-drm_mm.c
>> index 9aabe82dcd3a..4c08ca86bb86 100644
>> --- a/drivers/gpu/drm/selftests/test-drm_mm.c
>> +++ b/drivers/gpu/drm/selftests/test-drm_mm.c
>> @@ -1033,6 +1033,65 @@ static int igt_insert_range(void *ignored)
>>          return 0;
>>   }
>>   
>> +static int igt_frag(void *ignored)
>> +{
>> +       const struct insert_mode *mode;
>> +       struct drm_mm mm;
>> +       struct drm_mm_node *nodes, *node, *next;
>> +       unsigned int size = 4096, align = 8192;
>> +       unsigned long start, timeout = 1000;
>> +       const unsigned int max_count = 10000;
>> +       unsigned int i;
>> +       int ret = -EINVAL;
>> +
>> +       /* For each of the possible insertion modes, we pass an size, alignment
>> +        * value that is known to introduce fragmentation and check that it
>> +        * doesn't take more than 1 sec.
>> +        */
>> +
>> +       nodes = vzalloc(array_size(max_count, sizeof(*nodes)));
>> +       if (!nodes)
>> +               goto err;
>> +
>> +       drm_mm_init(&mm, 1, U64_MAX - 2);
>> +
>> +       for (mode = insert_modes; mode->name; mode++) {
>> +               start = jiffies;
>> +
>> +               for (i = 0; i < max_count; i++) {
>> +                       if (jiffies_to_msecs(jiffies - start) >= timeout) {
>> +                               pr_err("%s fragmented insert took more than %lu msecs\n",
>> +                                      mode->name, timeout);
>> +                               goto out;
> We will run into problems with fixed timeouts on slow devices (emulated
> virtual machines and whatnot). And yes there are a few that are known to
> run kernel selftests and send bug reports (and complain about slow
> tests such as the other drm_mm selftests :).


I had this in my mind but didn't think about emulated VMs :)


>
> Off the top of my head, we expect the fragmented search to scale
> [sub]linearly, whereas at the moment it's quadratic. How about if we do
> something like insert as many as we can within 50ms, and then verify
> that if we double that number of inserts it is less than 200ms. We will
> still run into fun with the CPU scheduler causing imprecise timing, but
> that should have sufficiently wide error margins.


This sounds like a good idea. I will send a v2 and cc to 
intel-gfx@lists.freedesktop.org as well.


Thanks,

Nirmoy


> -Chris
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Flists.freedesktop.org%2Fmailman%2Flistinfo%2Fdri-devel&amp;data=02%7C01%7Cnirmoy.das%40amd.com%7Cfc9863e63ecf452884d908d80320d969%7C3dd8961fe4884e608e11a82d994e183d%7C0%7C0%7C637262786936101207&amp;sdata=J%2Bpu1rYIsLv5KBpD89rTkU50w%2FABDcGCDWlMnutvy%2B4%3D&amp;reserved=0
Nirmoy May 29, 2020, 8:21 a.m. UTC | #2
On 5/28/20 8:49 PM, Christian König wrote:
> Am 28.05.20 um 15:05 schrieb Nirmoy Das:
>> This patch introduces fragmentation in the address range
>> and measures time taken by 10k insertions for each modes.
>>
>> ig_frag() will fail if one of the mode takes more than 1 sec.
>>
>> Output:
>> <snip>
>> [   37.326723] drm_mm: igt_sanitycheck - ok!
>> [   37.326727] igt_debug 0x0000000000000000-0x0000000000000200: 512: 
>> free
>> [   37.326728] igt_debug 0x0000000000000200-0x0000000000000600: 1024: 
>> used
>> [   37.326728] igt_debug 0x0000000000000600-0x0000000000000a00: 1024: 
>> free
>> [   37.326729] igt_debug 0x0000000000000a00-0x0000000000000e00: 1024: 
>> used
>> [   37.326730] igt_debug 0x0000000000000e00-0x0000000000001000: 512: 
>> free
>> [   37.326730] igt_debug total: 4096, used 2048 free 2048
>> [   56.040064] drm_mm: best fragmented insert took 504 msecs
>> [   56.082184] drm_mm: bottom-up fragmented insert took 40 msecs
>> [   56.102255] drm_mm: top-down fragmented insert took 20 msecs
>> [   56.107177] drm_mm: evict fragmented insert took 4 msecs
>> <snip>
>>
>> Signed-off-by: Nirmoy Das <nirmoy.das@amd.com>
>
> Off hand that looks like it should work, but I'm really not an expert 
> for the drm_mm code.
>
> Feel free to add an Acked-by: Christian König 
> <christian.koenig@amd.com>, but I would consider doing what Chris said 
> as well.


Thanks Christian,. Yes I will send a v2 with Chris's suggestions.


Nirmoy

>
> Christian.
>
>> ---
>>   drivers/gpu/drm/selftests/drm_mm_selftests.h |  1 +
>>   drivers/gpu/drm/selftests/test-drm_mm.c      | 59 ++++++++++++++++++++
>>   2 files changed, 60 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/selftests/drm_mm_selftests.h 
>> b/drivers/gpu/drm/selftests/drm_mm_selftests.h
>> index 6b943ea1c57d..8c87c964176b 100644
>> --- a/drivers/gpu/drm/selftests/drm_mm_selftests.h
>> +++ b/drivers/gpu/drm/selftests/drm_mm_selftests.h
>> @@ -14,6 +14,7 @@ selftest(insert, igt_insert)
>>   selftest(replace, igt_replace)
>>   selftest(insert_range, igt_insert_range)
>>   selftest(align, igt_align)
>> +selftest(frag, igt_frag)
>>   selftest(align32, igt_align32)
>>   selftest(align64, igt_align64)
>>   selftest(evict, igt_evict)
>> diff --git a/drivers/gpu/drm/selftests/test-drm_mm.c 
>> b/drivers/gpu/drm/selftests/test-drm_mm.c
>> index 9aabe82dcd3a..4c08ca86bb86 100644
>> --- a/drivers/gpu/drm/selftests/test-drm_mm.c
>> +++ b/drivers/gpu/drm/selftests/test-drm_mm.c
>> @@ -1033,6 +1033,65 @@ static int igt_insert_range(void *ignored)
>>       return 0;
>>   }
>>   +static int igt_frag(void *ignored)
>> +{
>> +    const struct insert_mode *mode;
>> +    struct drm_mm mm;
>> +    struct drm_mm_node *nodes, *node, *next;
>> +    unsigned int size = 4096, align = 8192;
>> +    unsigned long start, timeout = 1000;
>> +    const unsigned int max_count = 10000;
>> +    unsigned int i;
>> +    int ret = -EINVAL;
>> +
>> +    /* For each of the possible insertion modes, we pass an size, 
>> alignment
>> +     * value that is known to introduce fragmentation and check that it
>> +     * doesn't take more than 1 sec.
>> +     */
>> +
>> +    nodes = vzalloc(array_size(max_count, sizeof(*nodes)));
>> +    if (!nodes)
>> +        goto err;
>> +
>> +    drm_mm_init(&mm, 1, U64_MAX - 2);
>> +
>> +    for (mode = insert_modes; mode->name; mode++) {
>> +        start = jiffies;
>> +
>> +        for (i = 0; i < max_count; i++) {
>> +            if (jiffies_to_msecs(jiffies - start) >= timeout) {
>> +                pr_err("%s fragmented insert took more than %lu 
>> msecs\n",
>> +                       mode->name, timeout);
>> +                goto out;
>> +            }
>> +
>> +            if (!expect_insert(&mm, &nodes[i],
>> +                       size, align, i, mode)) {
>> +                pr_err("%s insert failed with alignment=%d",
>> +                       mode->name, align);
>> +                goto out;
>> +            }
>> +        }
>> +
>> +        pr_info("%s fragmented insert took %d msecs\n",
>> +            mode->name, jiffies_to_msecs(jiffies - start));
>> +        drm_mm_for_each_node_safe(node, next, &mm)
>> +            drm_mm_remove_node(node);
>> +        DRM_MM_BUG_ON(!drm_mm_clean(&mm));
>> +
>> +        cond_resched();
>> +    }
>> +
>> +    ret = 0;
>> +out:
>> +    drm_mm_for_each_node_safe(node, next, &mm)
>> +        drm_mm_remove_node(node);
>> +    drm_mm_takedown(&mm);
>> +    vfree(nodes);
>> +err:
>> +    return ret;
>> +}
>> +
>>   static int igt_align(void *ignored)
>>   {
>>       const struct insert_mode *mode;
>

Patch
diff mbox series

diff --git a/drivers/gpu/drm/selftests/drm_mm_selftests.h b/drivers/gpu/drm/selftests/drm_mm_selftests.h
index 6b943ea1c57d..8c87c964176b 100644
--- a/drivers/gpu/drm/selftests/drm_mm_selftests.h
+++ b/drivers/gpu/drm/selftests/drm_mm_selftests.h
@@ -14,6 +14,7 @@  selftest(insert, igt_insert)
 selftest(replace, igt_replace)
 selftest(insert_range, igt_insert_range)
 selftest(align, igt_align)
+selftest(frag, igt_frag)
 selftest(align32, igt_align32)
 selftest(align64, igt_align64)
 selftest(evict, igt_evict)
diff --git a/drivers/gpu/drm/selftests/test-drm_mm.c b/drivers/gpu/drm/selftests/test-drm_mm.c
index 9aabe82dcd3a..4c08ca86bb86 100644
--- a/drivers/gpu/drm/selftests/test-drm_mm.c
+++ b/drivers/gpu/drm/selftests/test-drm_mm.c
@@ -1033,6 +1033,65 @@  static int igt_insert_range(void *ignored)
 	return 0;
 }
 
+static int igt_frag(void *ignored)
+{
+	const struct insert_mode *mode;
+	struct drm_mm mm;
+	struct drm_mm_node *nodes, *node, *next;
+	unsigned int size = 4096, align = 8192;
+	unsigned long start, timeout = 1000;
+	const unsigned int max_count = 10000;
+	unsigned int i;
+	int ret = -EINVAL;
+
+	/* For each of the possible insertion modes, we pass an size, alignment
+	 * value that is known to introduce fragmentation and check that it
+	 * doesn't take more than 1 sec.
+	 */
+
+	nodes = vzalloc(array_size(max_count, sizeof(*nodes)));
+	if (!nodes)
+		goto err;
+
+	drm_mm_init(&mm, 1, U64_MAX - 2);
+
+	for (mode = insert_modes; mode->name; mode++) {
+		start = jiffies;
+
+		for (i = 0; i < max_count; i++) {
+			if (jiffies_to_msecs(jiffies - start) >= timeout) {
+				pr_err("%s fragmented insert took more than %lu msecs\n",
+				       mode->name, timeout);
+				goto out;
+			}
+
+			if (!expect_insert(&mm, &nodes[i],
+					   size, align, i, mode)) {
+				pr_err("%s insert failed with alignment=%d",
+				       mode->name, align);
+				goto out;
+			}
+		}
+
+		pr_info("%s fragmented insert took %d msecs\n",
+			mode->name, jiffies_to_msecs(jiffies - start));
+		drm_mm_for_each_node_safe(node, next, &mm)
+			drm_mm_remove_node(node);
+		DRM_MM_BUG_ON(!drm_mm_clean(&mm));
+
+		cond_resched();
+	}
+
+	ret = 0;
+out:
+	drm_mm_for_each_node_safe(node, next, &mm)
+		drm_mm_remove_node(node);
+	drm_mm_takedown(&mm);
+	vfree(nodes);
+err:
+	return ret;
+}
+
 static int igt_align(void *ignored)
 {
 	const struct insert_mode *mode;