[igt-dev] [PATCH i-g-t] igt/gem_sync: Alternate stress for nop+sync

[Antonio Argenziano]

On 18/06/18 06:43, Chris Wilson wrote:
> Apply a different sort of stress by timing how long it takes to sync a
> second nop batch in the the pipeline. We first start a spinner on the
> engine, then when we now the GPU is active, we submit the second nop;

Typo ^^^^^^^^^^^^^^

> start timing as we then release the spinner and wait for the nop to
> complete.
> 
> As with every other gem_sync test, it serves two roles. The first is
> that it checks that we do not miss a wakeup under common stressful
> conditions (the more conditions we check, the happier we will be that
> they do not occur in practice). And the second role it fulfils, is that
> it provides a very crude estimate for how long it takes for a nop to
> execute from a running start (we already have a complimentary estimate
> for an idle start).
> 
> Signed-off-by: Chris Wilson <chris at chris-wilson.co.uk>
> Cc: Joonas Lahtinen <joonas.lahtinen at linux.intel.com>
> ---
>   tests/gem_sync.c | 90 ++++++++++++++++++++++++++++++++++++++++++++++++
>   1 file changed, 90 insertions(+)
> 
> diff --git a/tests/gem_sync.c b/tests/gem_sync.c
> index 1e2e089a1..4cd97c58b 100644
> --- a/tests/gem_sync.c
> +++ b/tests/gem_sync.c
> @@ -177,6 +177,92 @@ idle_ring(int fd, unsigned ring, int timeout)
>   	gem_close(fd, object.handle);
>   }
>   
> +static void
> +wakeup_ring(int fd, unsigned ring, int timeout)
> +{

> +	intel_detect_and_clear_missed_interrupts(fd);
> +	igt_fork(child, num_engines) {
> +		const uint32_t bbe = MI_BATCH_BUFFER_END;
> +		struct drm_i915_gem_exec_object2 object;
> +		struct drm_i915_gem_execbuffer2 execbuf;
> +		double end, this, elapsed, now;
> +		unsigned long cycles;
> +		uint32_t cmd;
> +		igt_spin_t *spin;
> +
> +		memset(&object, 0, sizeof(object));
> +		object.handle = gem_create(fd, 4096);
> +		gem_write(fd, object.handle, 0, &bbe, sizeof(bbe));
> +
> +		memset(&execbuf, 0, sizeof(execbuf));
> +		execbuf.buffers_ptr = to_user_pointer(&object);
> +		execbuf.buffer_count = 1;
> +		execbuf.flags = engines[child % num_engines];
> +
> +		spin = __igt_spin_batch_new_poll(fd, 0, execbuf.flags);

Would be interesting to have the same test for batches on different 
contexts.

> +		igt_assert(spin->running);
> +		cmd = *spin->batch;
> +
> +		gem_execbuf(fd, &execbuf);
> +
> +		igt_spin_batch_end(spin);
> +		gem_sync(fd, object.handle);
> +

> +	}
> +	igt_waitchildren_timeout(timeout+10, NULL);
> +	igt_assert_eq(intel_detect_and_clear_missed_interrupts(fd), 0);

When do you think we will (if ever) be ready to establish a baseline and 
fail this kind of tests on a performance regression?

Just for the lazy reader, do we have the same kind of test where the 
spinner is preempted by the nop batch?

Thanks,
Antonio

> +}
> +