On Thu, Dec 01, 2016 at 03:31:44PM +0200, Mika Kuoppala wrote:
> If seqno is not incrementing but head is moving,
> we declare hang but much slower. Add test to check
> that this mechanism is working properly.
> 
> Signed-off-by: Mika Kuoppala <mika.kuopp...@intel.com>
> ---
>  tests/gem_reset_stats.c | 75 
> +++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 75 insertions(+)
> 
> diff --git a/tests/gem_reset_stats.c b/tests/gem_reset_stats.c
> index 2718a33..669a30a 100644
> --- a/tests/gem_reset_stats.c
> +++ b/tests/gem_reset_stats.c
> @@ -711,6 +711,75 @@ static void defer_hangcheck(const struct 
> intel_execution_engine *engine)
>       close(fd);
>  }
>  
> +static void test_no_seqno_progress(const struct intel_execution_engine 
> *engine,
> +                                const bool use_ctx)
> +{
> +     struct drm_i915_gem_relocation_entry reloc;
> +     struct drm_i915_gem_execbuffer2 eb;
> +     struct drm_i915_gem_exec_object2 exec;

I would advise using obj instead of exec

> +     struct local_drm_i915_reset_stats before, after;
> +     int len = 0, ctx, fd;
> +     uint32_t batch[16*1024];

Not needed, see later.
#define BATCH_SIZE (16 << 10)

> +     struct timespec ts_start;
> +
> +     fd = drm_open_driver(DRIVER_INTEL);
> +
> +     memset(&reloc, 0, sizeof(reloc));
> +        memset(&exec, 0, sizeof(exec));
> +        memset(&eb, 0, sizeof(eb));

> +     memset(&batch, 0, sizeof(batch));
> +
> +     exec.handle = gem_create(fd, sizeof(batch));
> +     exec.relocation_count = 1;
> +        exec.relocs_ptr = (uintptr_t)&reloc;
> +
> +     igt_assert((int)exec.handle > 0);

Already asserted for you.

> +
> +     if (use_ctx)
> +             ctx = gem_context_create(fd);
> +     else
> +             ctx = 0;
> +
> +     len = 2;
> +     if (intel_gen(intel_get_drm_devid(fd)) >= 8)
> +             len++;
> +
> +     batch[sizeof(batch)/sizeof(uint32_t) - len] = MI_BATCH_BUFFER_START | 
> (len - 2);
> +        gem_write(fd, exec.handle, 0, batch, sizeof(batch));

gem_write(fd, exec.handle, BATCH_SIZE - 16, &cmd, sizeof(cmd));

> +
> +        reloc.offset = sizeof(batch) - ((len-1) * 4);

reloc.offset = BATCH_SIZE - 16 + sizeof(cmd);

> +        reloc.delta = 0;
> +        reloc.target_handle = exec.handle;
> +        reloc.read_domains = I915_GEM_DOMAIN_COMMAND;

> +     eb.buffers_ptr = (uintptr_t)&exec;
> +     eb.buffer_count = 1;
> +     eb.flags = engine->exec_id;
> +        if (ctx)
> +             i915_execbuffer2_set_context_id(eb, ctx);

eb.rsvd1 = ctx; It's perfectly fine to set it to zero.

> +     igt_assert_eq(gem_reset_stats(fd, ctx, &before), 0);
> +
> +     clock_gettime(CLOCK_MONOTONIC, &ts_start);

struct timespec ts = {};
igt_seconds_elapsed(&ts_start)

> +
> +     igt_assert_eq(0, __gem_execbuf(fd, &eb));

gem_execbuf();

> +     igt_assert_lte(0, noop(fd, ctx, engine));

See earlier comments about noop.

> +     gem_sync(fd, exec.handle);
> +
> +     igt_assert_lte(0, noop(fd, ctx, engine));
> +     igt_assert_eq(gem_reset_stats(fd, ctx, &after), 0);
> +
> +     sync_gpu();
> +
> +     igt_assert(after.batch_active == before.batch_active + 1);

igt_assert_eq(after, before + 1);

> +     gem_close(fd, exec.handle);
> +     close(fd);
> +
> +     igt_assert(igt_seconds_elapsed(&ts_start) > 5);

You really want to demand a minimum time?

> +     igt_assert(igt_seconds_elapsed(&ts_start) < 15);

Play state thy sources. Upper bound should be closer to 120s.
-Chris

-- 
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reply via email to