tests/gem_exec_fence: test that in-fence is not overwritten

Submitted by Daniele Ceraolo Spurio on Feb. 14, 2018, 7:18 p.m.

Details

Message ID 20180214191827.8465-2-daniele.ceraolospurio@intel.com
State New
Series "tests/gem_exec_fence: test that in-fence is not overwritten"
Headers show

Commit Message

Daniele Ceraolo Spurio Feb. 14, 2018, 7:18 p.m.
When an out-fence is returned we expect that the in-fence is not
overwritten. Add a test to check for that.

Cc: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
---
 tests/gem_exec_fence.c | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

Patch hide | download patch | download mbox

diff --git a/tests/gem_exec_fence.c b/tests/gem_exec_fence.c
index bd7b1263..f7478c55 100644
--- a/tests/gem_exec_fence.c
+++ b/tests/gem_exec_fence.c
@@ -586,6 +586,42 @@  static void test_parallel(int fd, unsigned int master)
 	gem_close(fd, handle[0]);
 }
 
+/* check that a fence in doesn't get clobbered when a fence out is returned */
+static void test_keep_fence_in(int fd, unsigned int engine)
+{
+	struct drm_i915_gem_execbuffer2 execbuf;
+	struct drm_i915_gem_exec_object2 obj;
+	const uint32_t bbe = MI_BATCH_BUFFER_END;
+	int fence;
+
+	memset(&obj, 0, sizeof(obj));
+	memset(&execbuf, 0, sizeof(execbuf));
+
+	obj.handle = gem_create(fd, 4096);
+	gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe));
+
+	execbuf.buffers_ptr = to_user_pointer(&obj);
+	execbuf.buffer_count = 1;
+	execbuf.flags = engine | LOCAL_EXEC_FENCE_OUT;
+
+	gem_execbuf_wr(fd, &execbuf);
+	fence = execbuf.rsvd2 >> 32;
+
+	gem_close(fd, obj.handle);
+	obj.handle = gem_create(fd, 4096);
+	gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe));
+
+	execbuf.flags |= LOCAL_EXEC_FENCE_IN;
+	execbuf.rsvd2 = fence;
+
+	gem_execbuf_wr(fd, &execbuf);
+	igt_assert_eq(fence, execbuf.rsvd2 & 0xFFFFFFFF);
+
+	gem_close(fd, obj.handle);
+	close(fence);
+	close(execbuf.rsvd2 >> 32);
+}
+
 #define EXPIRED 0x10000
 static void test_long_history(int fd, long ring_size, unsigned flags)
 {
@@ -1499,6 +1535,9 @@  igt_main
 					}
 				}
 
+				igt_subtest_f("keep-fence-in-%s", e->name)
+					test_keep_fence_in(i915, e->exec_id | e->flags);
+
 				igt_fixture {
 					igt_stop_hang_detector();
 				}

Comments

Chris Wilson Feb. 14, 2018, 7:29 p.m.
Quoting Daniele Ceraolo Spurio (2018-02-14 19:18:26)
> When an out-fence is returned we expect that the in-fence is not
> overwritten. Add a test to check for that.
> 
> Cc: Chris Wilson <chris@chris-wilson.co.uk>
> Signed-off-by: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> ---
>  tests/gem_exec_fence.c | 39 +++++++++++++++++++++++++++++++++++++++
>  1 file changed, 39 insertions(+)
> 
> diff --git a/tests/gem_exec_fence.c b/tests/gem_exec_fence.c
> index bd7b1263..f7478c55 100644
> --- a/tests/gem_exec_fence.c
> +++ b/tests/gem_exec_fence.c
> @@ -586,6 +586,42 @@ static void test_parallel(int fd, unsigned int master)
>         gem_close(fd, handle[0]);
>  }
>  
> +/* check that a fence in doesn't get clobbered when a fence out is returned */
> +static void test_keep_fence_in(int fd, unsigned int engine)
> +{
> +       struct drm_i915_gem_execbuffer2 execbuf;
> +       struct drm_i915_gem_exec_object2 obj;
> +       const uint32_t bbe = MI_BATCH_BUFFER_END;
> +       int fence;
> +
> +       memset(&obj, 0, sizeof(obj));
> +       memset(&execbuf, 0, sizeof(execbuf));
> +
> +       obj.handle = gem_create(fd, 4096);
> +       gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe));
> +
> +       execbuf.buffers_ptr = to_user_pointer(&obj);
> +       execbuf.buffer_count = 1;
> +       execbuf.flags = engine | LOCAL_EXEC_FENCE_OUT;
> +
> +       gem_execbuf_wr(fd, &execbuf);
> +       fence = execbuf.rsvd2 >> 32;
> +
> +       gem_close(fd, obj.handle);
> +       obj.handle = gem_create(fd, 4096);
> +       gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe));

You don't need to recreate the batch here; just reusing the same handle
will do (and avoid the extra complication).

> +
> +       execbuf.flags |= LOCAL_EXEC_FENCE_IN;
> +       execbuf.rsvd2 = fence;
> +
> +       gem_execbuf_wr(fd, &execbuf);
> +       igt_assert_eq(fence, execbuf.rsvd2 & 0xFFFFFFFF);

This would be a good one to throw to the interruptible wolves.

static void test_keep_fence_in(int fd, unsigned int engine, unsigned int flags)
#define INTR 0x1

...
	igt_while_interruptible(flags & INTR)
		gem_execbuf_wr(fd, &execbuf);
	igt_assert_eq(fence, lower_32_bits(execbuf.rsvd2));

igt_subtest_f("keep-fence-in-%s", e->name)
	test_keep_fence_in(i915, e->exec_id | e->flags, 0);

igt_subtest_f("keep-fence-in-%s-interruptible", e->name)
	test_keep_fence_in(i915, e->exec_id | e->flags, INTR);

> +
> +       gem_close(fd, obj.handle);
> +       close(fence);
> +       close(execbuf.rsvd2 >> 32);
> +}
Chris Wilson Feb. 14, 2018, 7:34 p.m.
Quoting Chris Wilson (2018-02-14 19:29:29)
> Quoting Daniele Ceraolo Spurio (2018-02-14 19:18:26)
> > When an out-fence is returned we expect that the in-fence is not
> > overwritten. Add a test to check for that.
> > 
> > Cc: Chris Wilson <chris@chris-wilson.co.uk>
> > Signed-off-by: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
> > ---
> >  tests/gem_exec_fence.c | 39 +++++++++++++++++++++++++++++++++++++++
> >  1 file changed, 39 insertions(+)
> > 
> > diff --git a/tests/gem_exec_fence.c b/tests/gem_exec_fence.c
> > index bd7b1263..f7478c55 100644
> > --- a/tests/gem_exec_fence.c
> > +++ b/tests/gem_exec_fence.c
> > @@ -586,6 +586,42 @@ static void test_parallel(int fd, unsigned int master)
> >         gem_close(fd, handle[0]);
> >  }
> >  
> > +/* check that a fence in doesn't get clobbered when a fence out is returned */
> > +static void test_keep_fence_in(int fd, unsigned int engine)
> > +{
> > +       struct drm_i915_gem_execbuffer2 execbuf;
> > +       struct drm_i915_gem_exec_object2 obj;
> > +       const uint32_t bbe = MI_BATCH_BUFFER_END;
> > +       int fence;
> > +
> > +       memset(&obj, 0, sizeof(obj));
> > +       memset(&execbuf, 0, sizeof(execbuf));
> > +
> > +       obj.handle = gem_create(fd, 4096);
> > +       gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe));
> > +
> > +       execbuf.buffers_ptr = to_user_pointer(&obj);
> > +       execbuf.buffer_count = 1;
> > +       execbuf.flags = engine | LOCAL_EXEC_FENCE_OUT;
> > +
> > +       gem_execbuf_wr(fd, &execbuf);
> > +       fence = execbuf.rsvd2 >> 32;
> > +
> > +       gem_close(fd, obj.handle);
> > +       obj.handle = gem_create(fd, 4096);
> > +       gem_write(fd, obj.handle, 0, &bbe, sizeof(bbe));
> 
> You don't need to recreate the batch here; just reusing the same handle
> will do (and avoid the extra complication).
> 
> > +
> > +       execbuf.flags |= LOCAL_EXEC_FENCE_IN;
> > +       execbuf.rsvd2 = fence;
> > +
> > +       gem_execbuf_wr(fd, &execbuf);
> > +       igt_assert_eq(fence, execbuf.rsvd2 & 0xFFFFFFFF);
> 
> This would be a good one to throw to the interruptible wolves.

Of course to actually interrupt it, we need to hit a wait. Hmm. I'd use
a variant of the measure ring size approach, scrap the second test, and
then repeatedly re-submit until it hit an EINTR. (Obviously requires a
timer, and updating/checking the fences on each pass).
-Chris