icl offers a much reduced context space, and in its simplest setup we
cannot allocate one context per priority level, so trim the number and
reuse the same context for multiple priority requests.

v2: Bump the MAX to 1024 (still lower than the ~4096 previously in use)

Signed-off-by: Chris Wilson <ch...@chris-wilson.co.uk>
Acked-by: Antonio Argenziano <antonio.argenzi...@intel.com>
---
 tests/gem_exec_schedule.c | 38 +++++++++++++++++++++++---------------
 1 file changed, 23 insertions(+), 15 deletions(-)

diff --git a/tests/gem_exec_schedule.c b/tests/gem_exec_schedule.c
index 05f7ae38..8cdbd888 100644
--- a/tests/gem_exec_schedule.c
+++ b/tests/gem_exec_schedule.c
@@ -43,6 +43,8 @@
 #define BUSY_QLEN 8
 #define MAX_ELSP_QLEN 16
 
+#define MAX_CONTEXTS 1024
+
 IGT_TEST_DESCRIPTION("Check that we can control the order of execution");
 
 static void store_dword(int fd, uint32_t ctx, unsigned ring,
@@ -556,8 +558,8 @@ static void preemptive_hang(int fd, unsigned ring)
 static void deep(int fd, unsigned ring)
 {
 #define XS 8
-       const unsigned int nctx = MAX_PRIO - MIN_PRIO;
-       const unsigned size = ALIGN(4*nctx, 4096);
+       const unsigned int nreq = MAX_PRIO - MIN_PRIO;
+       const unsigned size = ALIGN(4*nreq, 4096);
        struct timespec tv = {};
        struct cork cork;
        uint32_t result, dep[XS];
@@ -565,10 +567,9 @@ static void deep(int fd, unsigned ring)
        uint32_t *ptr;
        uint32_t *ctx;
 
-       ctx = malloc(sizeof(*ctx) * nctx);
-       for (int n = 0; n < nctx; n++) {
+       ctx = malloc(sizeof(*ctx) * MAX_CONTEXTS);
+       for (int n = 0; n < MAX_CONTEXTS; n++) {
                ctx[n] = gem_context_create(fd);
-               gem_context_set_priority(fd, ctx[n], MAX_PRIO - nctx + n);
        }
 
        result = gem_create(fd, size);
@@ -592,7 +593,7 @@ static void deep(int fd, unsigned ring)
                execbuf.buffers_ptr = to_user_pointer(obj);
                execbuf.buffer_count = XS + 2;
                execbuf.flags = ring;
-               for (int n = 0; n < nctx; n++) {
+               for (int n = 0; n < MAX_CONTEXTS; n++) {
                        execbuf.rsvd1 = ctx[n];
                        gem_execbuf(fd, &execbuf);
                }
@@ -603,22 +604,29 @@ static void deep(int fd, unsigned ring)
        plug(fd, &cork);
 
        /* Create a deep dependency chain, with a few branches */
-       for (int n = 0; n < nctx && igt_seconds_elapsed(&tv) < 8; n++)
+       for (int n = 0; n < nreq && igt_seconds_elapsed(&tv) < 8; n++) {
+               uint32_t context = ctx[n % MAX_CONTEXTS];
+               gem_context_set_priority(fd, context, MAX_PRIO - nreq + n);
+
                for (int m = 0; m < XS; m++)
-                       store_dword(fd, ctx[n], ring, dep[m], 4*n, ctx[n], 
cork.handle, I915_GEM_DOMAIN_INSTRUCTION);
+                       store_dword(fd, context, ring, dep[m], 4*n, context, 
cork.handle, I915_GEM_DOMAIN_INSTRUCTION);
+       }
+
+       for (int n = 0; n < nreq && igt_seconds_elapsed(&tv) < 6; n++) {
+               uint32_t context = ctx[n % MAX_CONTEXTS];
+               gem_context_set_priority(fd, context, MAX_PRIO - nreq + n);
 
-       for (int n = 0; n < nctx && igt_seconds_elapsed(&tv) < 6; n++) {
                for (int m = 0; m < XS; m++) {
-                       store_dword(fd, ctx[n], ring, result, 4*n, ctx[n], 
dep[m], 0);
-                       store_dword(fd, ctx[n], ring, result, 4*m, ctx[n], 0, 
I915_GEM_DOMAIN_INSTRUCTION);
+                       store_dword(fd, context, ring, result, 4*n, context, 
dep[m], 0);
+                       store_dword(fd, context, ring, result, 4*m, context, 0, 
I915_GEM_DOMAIN_INSTRUCTION);
                }
-               expected = ctx[n];
+               expected = context;
        }
 
        unplug_show_queue(fd, &cork, ring);
        igt_require(expected); /* too slow */
 
-       for (int n = 0; n < nctx; n++)
+       for (int n = 0; n < MAX_CONTEXTS; n++)
                gem_context_destroy(fd, ctx[n]);
 
        for (int m = 0; m < XS; m++) {
@@ -627,8 +635,8 @@ static void deep(int fd, unsigned ring)
                                I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
                gem_close(fd, dep[m]);
 
-               for (int n = 0; n < nctx; n++)
-                       igt_assert_eq_u32(ptr[n], ctx[n]);
+               for (int n = 0; n < nreq; n++)
+                       igt_assert_eq_u32(ptr[n], ctx[n % MAX_CONTEXTS]);
                munmap(ptr, size);
        }
 
-- 
2.16.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to