[PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

Verify that the reported busyness is in line with what would we expect
from a batch which causes a hang and gets kicked out from the engine.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 tests/perf_pmu.c | 41 +++++++++++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 6 deletions(-)

diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
index 7fab73e22c2d..90b6ec4db32d 100644
--- a/tests/perf_pmu.c
+++ b/tests/perf_pmu.c
@@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
 #define TEST_TRAILING_IDLE (4)
 #define TEST_RUNTIME_PM (8)
 #define FLAG_LONG (16)
+#define FLAG_HANG (32)
 
 static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 {
@@ -186,11 +187,15 @@ static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 static void
 single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 {
+	const unsigned int hang_us = 10e6;
 	unsigned long slept;
 	igt_spin_t *spin;
-	uint64_t val;
+	uint64_t val[2], ts[2];
 	int fd;
 
+	if (flags & FLAG_HANG)
+		gem_quiescent_gpu(gem_fd);
+
 	fd = open_pmu(I915_PMU_ENGINE_BUSY(e->class, e->instance));
 
 	if (flags & TEST_BUSY)
@@ -198,17 +203,36 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 	else
 		spin = NULL;
 
-	val = pmu_read_single(fd);
-	slept = measured_usleep(batch_duration_ns / 1000);
+	val[0] = __pmu_read_single(fd, &ts[0]);
+	slept = measured_usleep(flags & FLAG_HANG ?
+				hang_us : batch_duration_ns / 1000);
 	if (flags & TEST_TRAILING_IDLE)
 		end_spin(gem_fd, spin, flags);
-	val = pmu_read_single(fd) - val;
+	val[1] = pmu_read_single(fd);
 
 	end_spin(gem_fd, spin, FLAG_SYNC);
 	igt_spin_batch_free(gem_fd, spin);
-	close(fd);
 
-	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
+	if ((flags & TEST_BUSY) && (flags & FLAG_HANG)) {
+		val[1] = __pmu_read_single(fd, &ts[1]);
+		close(fd);
+		igt_info("sampled with hang %.3fms / %.3fms\n",
+			 (val[1] - val[0]) / 1e6, (ts[1] - ts[0]) / 1e6);
+		/* Check that some busyness was reported. */
+		igt_assert(val[1] - val[0] > 0);
+		/*
+		 * But not more than some reasonable value before which we
+		 * expected the spinner to be kicked out.
+		 */
+		igt_assert((val[1] - val[0]) / 1e3 < (double)hang_us * 0.75);
+		__assert_within_epsilon(val[1] - val[0], hang_us * 1e3,
+					0.02f, 10.0f);
+	} else {
+		close(fd);
+		assert_within_epsilon(val[1] - val[0],
+				      flags & TEST_BUSY ?
+				      slept : 0.f, tolerance);
+	}
 	gem_quiescent_gpu(gem_fd);
 }
 
@@ -1695,6 +1719,11 @@ igt_main
 					      pct[i], e->name)
 					accuracy(fd, e, pct[i]);
 			}
+
+			igt_subtest_f("busy-hang-%s", e->name) {
+				single(fd, e, TEST_BUSY | FLAG_HANG);
+				single(fd, e, TEST_BUSY | FLAG_HANG);
+			}
 		}
 
 		/**
-- 
2.14.1

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

[Intel-gfx] [PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

Verify that the reported busyness is in line with what would we expect
from a batch which causes a hang and gets kicked out from the engine.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 tests/perf_pmu.c | 41 +++++++++++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 6 deletions(-)

diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
index 7fab73e22c2d..90b6ec4db32d 100644
--- a/tests/perf_pmu.c
+++ b/tests/perf_pmu.c
@@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
 #define TEST_TRAILING_IDLE (4)
 #define TEST_RUNTIME_PM (8)
 #define FLAG_LONG (16)
+#define FLAG_HANG (32)
 
 static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 {
@@ -186,11 +187,15 @@ static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 static void
 single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 {
+	const unsigned int hang_us = 10e6;
 	unsigned long slept;
 	igt_spin_t *spin;
-	uint64_t val;
+	uint64_t val[2], ts[2];
 	int fd;
 
+	if (flags & FLAG_HANG)
+		gem_quiescent_gpu(gem_fd);
+
 	fd = open_pmu(I915_PMU_ENGINE_BUSY(e->class, e->instance));
 
 	if (flags & TEST_BUSY)
@@ -198,17 +203,36 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 	else
 		spin = NULL;
 
-	val = pmu_read_single(fd);
-	slept = measured_usleep(batch_duration_ns / 1000);
+	val[0] = __pmu_read_single(fd, &ts[0]);
+	slept = measured_usleep(flags & FLAG_HANG ?
+				hang_us : batch_duration_ns / 1000);
 	if (flags & TEST_TRAILING_IDLE)
 		end_spin(gem_fd, spin, flags);
-	val = pmu_read_single(fd) - val;
+	val[1] = pmu_read_single(fd);
 
 	end_spin(gem_fd, spin, FLAG_SYNC);
 	igt_spin_batch_free(gem_fd, spin);
-	close(fd);
 
-	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
+	if ((flags & TEST_BUSY) && (flags & FLAG_HANG)) {
+		val[1] = __pmu_read_single(fd, &ts[1]);
+		close(fd);
+		igt_info("sampled with hang %.3fms / %.3fms\n",
+			 (val[1] - val[0]) / 1e6, (ts[1] - ts[0]) / 1e6);
+		/* Check that some busyness was reported. */
+		igt_assert(val[1] - val[0] > 0);
+		/*
+		 * But not more than some reasonable value before which we
+		 * expected the spinner to be kicked out.
+		 */
+		igt_assert((val[1] - val[0]) / 1e3 < (double)hang_us * 0.75);
+		__assert_within_epsilon(val[1] - val[0], hang_us * 1e3,
+					0.02f, 10.0f);
+	} else {
+		close(fd);
+		assert_within_epsilon(val[1] - val[0],
+				      flags & TEST_BUSY ?
+				      slept : 0.f, tolerance);
+	}
 	gem_quiescent_gpu(gem_fd);
 }
 
@@ -1695,6 +1719,11 @@ igt_main
 					      pct[i], e->name)
 					accuracy(fd, e, pct[i]);
 			}
+
+			igt_subtest_f("busy-hang-%s", e->name) {
+				single(fd, e, TEST_BUSY | FLAG_HANG);
+				single(fd, e, TEST_BUSY | FLAG_HANG);
+			}
 		}
 
 		/**
-- 
2.14.1

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

Re: [igt-dev] [PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Chris Wilson]

Quoting Tvrtko Ursulin (2018-02-19 19:12:51)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> Verify that the reported busyness is in line with what would we expect
> from a batch which causes a hang and gets kicked out from the engine.
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> ---
>  tests/perf_pmu.c | 41 +++++++++++++++++++++++++++++++++++------
>  1 file changed, 35 insertions(+), 6 deletions(-)
> 
> diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
> index 7fab73e22c2d..90b6ec4db32d 100644
> --- a/tests/perf_pmu.c
> +++ b/tests/perf_pmu.c
> @@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
>  #define TEST_TRAILING_IDLE (4)
>  #define TEST_RUNTIME_PM (8)
>  #define FLAG_LONG (16)
> +#define FLAG_HANG (32)
>  
>  static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>  {
> @@ -186,11 +187,15 @@ static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>  static void
>  single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>  {
> +       const unsigned int hang_us = 10e6;
>         unsigned long slept;
>         igt_spin_t *spin;
> -       uint64_t val;
> +       uint64_t val[2], ts[2];
>         int fd;
>  
> +       if (flags & FLAG_HANG)
> +               gem_quiescent_gpu(gem_fd);
> +
>         fd = open_pmu(I915_PMU_ENGINE_BUSY(e->class, e->instance));
>  
>         if (flags & TEST_BUSY)
> @@ -198,17 +203,36 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>         else
>                 spin = NULL;
>  
> -       val = pmu_read_single(fd);
> -       slept = measured_usleep(batch_duration_ns / 1000);
> +       val[0] = __pmu_read_single(fd, &ts[0]);
> +       slept = measured_usleep(flags & FLAG_HANG ?
> +                               hang_us : batch_duration_ns / 1000);
>         if (flags & TEST_TRAILING_IDLE)
>                 end_spin(gem_fd, spin, flags);
> -       val = pmu_read_single(fd) - val;
> +       val[1] = pmu_read_single(fd);
>  
>         end_spin(gem_fd, spin, FLAG_SYNC);
>         igt_spin_batch_free(gem_fd, spin);
> -       close(fd);
>  
> -       assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
> +       if ((flags & TEST_BUSY) && (flags & FLAG_HANG)) {
> +               val[1] = __pmu_read_single(fd, &ts[1]);
> +               close(fd);
> +               igt_info("sampled with hang %.3fms / %.3fms\n",
> +                        (val[1] - val[0]) / 1e6, (ts[1] - ts[0]) / 1e6);
> +               /* Check that some busyness was reported. */
> +               igt_assert(val[1] - val[0] > 0);
> +               /*
> +                * But not more than some reasonable value before which we
> +                * expected the spinner to be kicked out.
> +                */

So 120s? And even that carries internal knowledge from across the ages.

I don't think this is a sensible test. What would be reasonable is
something like

	spinner()
	val[0] = pmu()
	sleep()
	igt_force_gpu_reset()
	val[1] = pmu();
	d_busy = val[1] - val[0]
	sleep()
	val[2] = pmu()
	d_idle = val[2] - val[1];

Then d_busy should be d_ts, and d_idle should be 0. i.e. the
igt_force_gpu_reset() is just an indirect igt_spin_batch_end().
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [igt-dev] [PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Chris Wilson]

Quoting Tvrtko Ursulin (2018-02-19 19:12:51)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> Verify that the reported busyness is in line with what would we expect
> from a batch which causes a hang and gets kicked out from the engine.
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> ---
>  tests/perf_pmu.c | 41 +++++++++++++++++++++++++++++++++++------
>  1 file changed, 35 insertions(+), 6 deletions(-)
> 
> diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
> index 7fab73e22c2d..90b6ec4db32d 100644
> --- a/tests/perf_pmu.c
> +++ b/tests/perf_pmu.c
> @@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
>  #define TEST_TRAILING_IDLE (4)
>  #define TEST_RUNTIME_PM (8)
>  #define FLAG_LONG (16)
> +#define FLAG_HANG (32)
>  
>  static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>  {
> @@ -186,11 +187,15 @@ static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>  static void
>  single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>  {
> +       const unsigned int hang_us = 10e6;
>         unsigned long slept;
>         igt_spin_t *spin;
> -       uint64_t val;
> +       uint64_t val[2], ts[2];
>         int fd;
>  
> +       if (flags & FLAG_HANG)
> +               gem_quiescent_gpu(gem_fd);
> +
>         fd = open_pmu(I915_PMU_ENGINE_BUSY(e->class, e->instance));
>  
>         if (flags & TEST_BUSY)
> @@ -198,17 +203,36 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>         else
>                 spin = NULL;
>  
> -       val = pmu_read_single(fd);
> -       slept = measured_usleep(batch_duration_ns / 1000);
> +       val[0] = __pmu_read_single(fd, &ts[0]);
> +       slept = measured_usleep(flags & FLAG_HANG ?
> +                               hang_us : batch_duration_ns / 1000);
>         if (flags & TEST_TRAILING_IDLE)
>                 end_spin(gem_fd, spin, flags);
> -       val = pmu_read_single(fd) - val;
> +       val[1] = pmu_read_single(fd);
>  
>         end_spin(gem_fd, spin, FLAG_SYNC);
>         igt_spin_batch_free(gem_fd, spin);
> -       close(fd);
>  
> -       assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
> +       if ((flags & TEST_BUSY) && (flags & FLAG_HANG)) {
> +               val[1] = __pmu_read_single(fd, &ts[1]);
> +               close(fd);
> +               igt_info("sampled with hang %.3fms / %.3fms\n",
> +                        (val[1] - val[0]) / 1e6, (ts[1] - ts[0]) / 1e6);
> +               /* Check that some busyness was reported. */
> +               igt_assert(val[1] - val[0] > 0);
> +               /*
> +                * But not more than some reasonable value before which we
> +                * expected the spinner to be kicked out.
> +                */

So 120s? And even that carries internal knowledge from across the ages.

I don't think this is a sensible test. What would be reasonable is
something like

	spinner()
	val[0] = pmu()
	sleep()
	igt_force_gpu_reset()
	val[1] = pmu();
	d_busy = val[1] - val[0]
	sleep()
	val[2] = pmu()
	d_idle = val[2] - val[1];

Then d_busy should be d_ts, and d_idle should be 0. i.e. the
igt_force_gpu_reset() is just an indirect igt_spin_batch_end().
-Chris
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

On 19/02/2018 19:21, Chris Wilson wrote:
> Quoting Tvrtko Ursulin (2018-02-19 19:12:51)
>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>
>> Verify that the reported busyness is in line with what would we expect
>> from a batch which causes a hang and gets kicked out from the engine.
>>
>> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>> ---
>>   tests/perf_pmu.c | 41 +++++++++++++++++++++++++++++++++++------
>>   1 file changed, 35 insertions(+), 6 deletions(-)
>>
>> diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
>> index 7fab73e22c2d..90b6ec4db32d 100644
>> --- a/tests/perf_pmu.c
>> +++ b/tests/perf_pmu.c
>> @@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
>>   #define TEST_TRAILING_IDLE (4)
>>   #define TEST_RUNTIME_PM (8)
>>   #define FLAG_LONG (16)
>> +#define FLAG_HANG (32)
>>   
>>   static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>>   {
>> @@ -186,11 +187,15 @@ static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>>   static void
>>   single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>>   {
>> +       const unsigned int hang_us = 10e6;
>>          unsigned long slept;
>>          igt_spin_t *spin;
>> -       uint64_t val;
>> +       uint64_t val[2], ts[2];
>>          int fd;
>>   
>> +       if (flags & FLAG_HANG)
>> +               gem_quiescent_gpu(gem_fd);
>> +
>>          fd = open_pmu(I915_PMU_ENGINE_BUSY(e->class, e->instance));
>>   
>>          if (flags & TEST_BUSY)
>> @@ -198,17 +203,36 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>>          else
>>                  spin = NULL;
>>   
>> -       val = pmu_read_single(fd);
>> -       slept = measured_usleep(batch_duration_ns / 1000);
>> +       val[0] = __pmu_read_single(fd, &ts[0]);
>> +       slept = measured_usleep(flags & FLAG_HANG ?
>> +                               hang_us : batch_duration_ns / 1000);
>>          if (flags & TEST_TRAILING_IDLE)
>>                  end_spin(gem_fd, spin, flags);
>> -       val = pmu_read_single(fd) - val;
>> +       val[1] = pmu_read_single(fd);
>>   
>>          end_spin(gem_fd, spin, FLAG_SYNC);
>>          igt_spin_batch_free(gem_fd, spin);
>> -       close(fd);
>>   
>> -       assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
>> +       if ((flags & TEST_BUSY) && (flags & FLAG_HANG)) {
>> +               val[1] = __pmu_read_single(fd, &ts[1]);
>> +               close(fd);
>> +               igt_info("sampled with hang %.3fms / %.3fms\n",
>> +                        (val[1] - val[0]) / 1e6, (ts[1] - ts[0]) / 1e6);
>> +               /* Check that some busyness was reported. */
>> +               igt_assert(val[1] - val[0] > 0);
>> +               /*
>> +                * But not more than some reasonable value before which we
>> +                * expected the spinner to be kicked out.
>> +                */
> 
> So 120s? And even that carries internal knowledge from across the ages.
> 
> I don't think this is a sensible test. What would be reasonable is
> something like
> 
> 	spinner()
> 	val[0] = pmu()
> 	sleep()
> 	igt_force_gpu_reset()
> 	val[1] = pmu();
> 	d_busy = val[1] - val[0]
> 	sleep()
> 	val[2] = pmu()
> 	d_idle = val[2] - val[1];
> 
> Then d_busy should be d_ts, and d_idle should be 0. i.e. the
> igt_force_gpu_reset() is just an indirect igt_spin_batch_end().

Yeah I am not claiming the test is great. I threw it together quickly 
when I suspected something is going bad. Just want to get some results 
overnight so I can despair tomorrow.

Regards,

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

Re: [igt-dev] [Intel-gfx] [PATCH i-g-t] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

On 19/02/2018 19:21, Chris Wilson wrote:
> Quoting Tvrtko Ursulin (2018-02-19 19:12:51)
>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>
>> Verify that the reported busyness is in line with what would we expect
>> from a batch which causes a hang and gets kicked out from the engine.
>>
>> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>> ---
>>   tests/perf_pmu.c | 41 +++++++++++++++++++++++++++++++++++------
>>   1 file changed, 35 insertions(+), 6 deletions(-)
>>
>> diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
>> index 7fab73e22c2d..90b6ec4db32d 100644
>> --- a/tests/perf_pmu.c
>> +++ b/tests/perf_pmu.c
>> @@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
>>   #define TEST_TRAILING_IDLE (4)
>>   #define TEST_RUNTIME_PM (8)
>>   #define FLAG_LONG (16)
>> +#define FLAG_HANG (32)
>>   
>>   static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>>   {
>> @@ -186,11 +187,15 @@ static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
>>   static void
>>   single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>>   {
>> +       const unsigned int hang_us = 10e6;
>>          unsigned long slept;
>>          igt_spin_t *spin;
>> -       uint64_t val;
>> +       uint64_t val[2], ts[2];
>>          int fd;
>>   
>> +       if (flags & FLAG_HANG)
>> +               gem_quiescent_gpu(gem_fd);
>> +
>>          fd = open_pmu(I915_PMU_ENGINE_BUSY(e->class, e->instance));
>>   
>>          if (flags & TEST_BUSY)
>> @@ -198,17 +203,36 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
>>          else
>>                  spin = NULL;
>>   
>> -       val = pmu_read_single(fd);
>> -       slept = measured_usleep(batch_duration_ns / 1000);
>> +       val[0] = __pmu_read_single(fd, &ts[0]);
>> +       slept = measured_usleep(flags & FLAG_HANG ?
>> +                               hang_us : batch_duration_ns / 1000);
>>          if (flags & TEST_TRAILING_IDLE)
>>                  end_spin(gem_fd, spin, flags);
>> -       val = pmu_read_single(fd) - val;
>> +       val[1] = pmu_read_single(fd);
>>   
>>          end_spin(gem_fd, spin, FLAG_SYNC);
>>          igt_spin_batch_free(gem_fd, spin);
>> -       close(fd);
>>   
>> -       assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
>> +       if ((flags & TEST_BUSY) && (flags & FLAG_HANG)) {
>> +               val[1] = __pmu_read_single(fd, &ts[1]);
>> +               close(fd);
>> +               igt_info("sampled with hang %.3fms / %.3fms\n",
>> +                        (val[1] - val[0]) / 1e6, (ts[1] - ts[0]) / 1e6);
>> +               /* Check that some busyness was reported. */
>> +               igt_assert(val[1] - val[0] > 0);
>> +               /*
>> +                * But not more than some reasonable value before which we
>> +                * expected the spinner to be kicked out.
>> +                */
> 
> So 120s? And even that carries internal knowledge from across the ages.
> 
> I don't think this is a sensible test. What would be reasonable is
> something like
> 
> 	spinner()
> 	val[0] = pmu()
> 	sleep()
> 	igt_force_gpu_reset()
> 	val[1] = pmu();
> 	d_busy = val[1] - val[0]
> 	sleep()
> 	val[2] = pmu()
> 	d_idle = val[2] - val[1];
> 
> Then d_busy should be d_ts, and d_idle should be 0. i.e. the
> igt_force_gpu_reset() is just an indirect igt_spin_batch_end().

Yeah I am not claiming the test is great. I threw it together quickly 
when I suspected something is going bad. Just want to get some results 
overnight so I can despair tomorrow.

Regards,

Tvrtko
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

Verify that the reported busyness is in line with what would we expect
from a batch which causes a hang and gets kicked out from the engine.

v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
    batch will hang. (Chris Wilson)

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 tests/perf_pmu.c | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
index 3bbb18d2f216..f5c70776e2cf 100644
--- a/tests/perf_pmu.c
+++ b/tests/perf_pmu.c
@@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
 #define TEST_TRAILING_IDLE (4)
 #define TEST_RUNTIME_PM (8)
 #define FLAG_LONG (16)
+#define FLAG_HANG (32)
 
 static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 {
@@ -204,11 +205,27 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 		end_spin(gem_fd, spin, flags);
 	val = pmu_read_single(fd) - val;
 
-	end_spin(gem_fd, spin, FLAG_SYNC);
+	if (flags & FLAG_HANG)
+		igt_force_gpu_reset(gem_fd);
+	else
+		end_spin(gem_fd, spin, FLAG_SYNC);
+
+	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
+
+	/* Check for idle after hang. */
+	if (flags & FLAG_HANG) {
+		/* Sleep for a bit for reset unwind to settle. */
+		sleep(1);
+		val = pmu_read_single(fd);
+		slept = measured_usleep(batch_duration_ns / 1000);
+		val = pmu_read_single(fd) - val;
+
+		assert_within_epsilon(val, 0, tolerance);
+	}
+
 	igt_spin_batch_free(gem_fd, spin);
 	close(fd);
 
-	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
 	gem_quiescent_gpu(gem_fd);
 }
 
@@ -1690,6 +1707,9 @@ igt_main
 					      pct[i], e->name)
 					accuracy(fd, e, pct[i]);
 			}
+
+			igt_subtest_f("busy-hang-%s", e->name)
+				single(fd, e, TEST_BUSY | FLAG_HANG);
 		}
 
 		/**
-- 
2.14.1

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

[Intel-gfx] [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

Verify that the reported busyness is in line with what would we expect
from a batch which causes a hang and gets kicked out from the engine.

v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
    batch will hang. (Chris Wilson)

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 tests/perf_pmu.c | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
index 3bbb18d2f216..f5c70776e2cf 100644
--- a/tests/perf_pmu.c
+++ b/tests/perf_pmu.c
@@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
 #define TEST_TRAILING_IDLE (4)
 #define TEST_RUNTIME_PM (8)
 #define FLAG_LONG (16)
+#define FLAG_HANG (32)
 
 static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 {
@@ -204,11 +205,27 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 		end_spin(gem_fd, spin, flags);
 	val = pmu_read_single(fd) - val;
 
-	end_spin(gem_fd, spin, FLAG_SYNC);
+	if (flags & FLAG_HANG)
+		igt_force_gpu_reset(gem_fd);
+	else
+		end_spin(gem_fd, spin, FLAG_SYNC);
+
+	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
+
+	/* Check for idle after hang. */
+	if (flags & FLAG_HANG) {
+		/* Sleep for a bit for reset unwind to settle. */
+		sleep(1);
+		val = pmu_read_single(fd);
+		slept = measured_usleep(batch_duration_ns / 1000);
+		val = pmu_read_single(fd) - val;
+
+		assert_within_epsilon(val, 0, tolerance);
+	}
+
 	igt_spin_batch_free(gem_fd, spin);
 	close(fd);
 
-	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
 	gem_quiescent_gpu(gem_fd);
 }
 
@@ -1690,6 +1707,9 @@ igt_main
 					      pct[i], e->name)
 					accuracy(fd, e, pct[i]);
 			}
+
+			igt_subtest_f("busy-hang-%s", e->name)
+				single(fd, e, TEST_BUSY | FLAG_HANG);
 		}
 
 		/**
-- 
2.14.1

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

Re: [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Chris Wilson]

Quoting Tvrtko Ursulin (2018-02-28 17:15:19)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> Verify that the reported busyness is in line with what would we expect
> from a batch which causes a hang and gets kicked out from the engine.
> 
> v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
>     batch will hang. (Chris Wilson)
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

It's nice and quick, yes. However, sometime the opposite is true and you
have to wait for the batch you want to start before pulling the trigger.

I'd put a usleep(100) in there /* Wait for batch to execute */ and we
should put the wait-for-execution ability in igt_spin_t. Unfortunately
that requires MI_STORE_DWORD_IMM (or more creativity) limiting it's
availability.

With the sleep issue addressed (commented upon if nothing else),
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Chris Wilson]

Quoting Tvrtko Ursulin (2018-02-28 17:15:19)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> Verify that the reported busyness is in line with what would we expect
> from a batch which causes a hang and gets kicked out from the engine.
> 
> v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
>     batch will hang. (Chris Wilson)
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

It's nice and quick, yes. However, sometime the opposite is true and you
have to wait for the batch you want to start before pulling the trigger.

I'd put a usleep(100) in there /* Wait for batch to execute */ and we
should put the wait-for-execution ability in igt_spin_t. Unfortunately
that requires MI_STORE_DWORD_IMM (or more creativity) limiting it's
availability.

With the sleep issue addressed (commented upon if nothing else),
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

On 01/03/2018 08:08, Chris Wilson wrote:
> Quoting Tvrtko Ursulin (2018-02-28 17:15:19)
>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>
>> Verify that the reported busyness is in line with what would we expect
>> from a batch which causes a hang and gets kicked out from the engine.
>>
>> v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
>>      batch will hang. (Chris Wilson)
>>
>> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> It's nice and quick, yes. However, sometime the opposite is true and you
> have to wait for the batch you want to start before pulling the trigger.
> 
> I'd put a usleep(100) in there /* Wait for batch to execute */ and we

Hm, but reset is triggered after the first sleep (which checks for 100% 
busy). So even the non-hanging test flavour could be affect if the delay 
before execution is so long. So by this logic this usleep(100) (or more 
for small core CI) should then go to many tests. Only difference in the 
hang flavour is that if it completely failed to run until after the 
reset, then the idle assert would fail. So maybe I should just add an 
assert that the batch is idle before sampling pmu after reset?

Regards,

Tvrtko

> should put the wait-for-execution ability in igt_spin_t. Unfortunately
> that requires MI_STORE_DWORD_IMM (or more creativity) limiting it's
> availability.
> 
> With the sleep issue addressed (commented upon if nothing else),
> Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
> -Chris
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
> 
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [igt-dev] [Intel-gfx] [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

On 01/03/2018 08:08, Chris Wilson wrote:
> Quoting Tvrtko Ursulin (2018-02-28 17:15:19)
>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>
>> Verify that the reported busyness is in line with what would we expect
>> from a batch which causes a hang and gets kicked out from the engine.
>>
>> v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
>>      batch will hang. (Chris Wilson)
>>
>> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> It's nice and quick, yes. However, sometime the opposite is true and you
> have to wait for the batch you want to start before pulling the trigger.
> 
> I'd put a usleep(100) in there /* Wait for batch to execute */ and we

Hm, but reset is triggered after the first sleep (which checks for 100% 
busy). So even the non-hanging test flavour could be affect if the delay 
before execution is so long. So by this logic this usleep(100) (or more 
for small core CI) should then go to many tests. Only difference in the 
hang flavour is that if it completely failed to run until after the 
reset, then the idle assert would fail. So maybe I should just add an 
assert that the batch is idle before sampling pmu after reset?

Regards,

Tvrtko

> should put the wait-for-execution ability in igt_spin_t. Unfortunately
> that requires MI_STORE_DWORD_IMM (or more creativity) limiting it's
> availability.
> 
> With the sleep issue addressed (commented upon if nothing else),
> Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
> -Chris
> _______________________________________________
> Intel-gfx mailing list
> Intel-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/intel-gfx
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Chris Wilson]

Quoting Tvrtko Ursulin (2018-03-01 09:21:52)
> 
> On 01/03/2018 08:08, Chris Wilson wrote:
> > Quoting Tvrtko Ursulin (2018-02-28 17:15:19)
> >> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> >>
> >> Verify that the reported busyness is in line with what would we expect
> >> from a batch which causes a hang and gets kicked out from the engine.
> >>
> >> v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
> >>      batch will hang. (Chris Wilson)
> >>
> >> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> > 
> > It's nice and quick, yes. However, sometime the opposite is true and you
> > have to wait for the batch you want to start before pulling the trigger.
> > 
> > I'd put a usleep(100) in there /* Wait for batch to execute */ and we
> 
> Hm, but reset is triggered after the first sleep (which checks for 100% 
> busy). So even the non-hanging test flavour could be affect if the delay 
> before execution is so long. So by this logic this usleep(100) (or more 
> for small core CI) should then go to many tests. Only difference in the 
> hang flavour is that if it completely failed to run until after the 
> reset, then the idle assert would fail. So maybe I should just add an 
> assert that the batch is idle before sampling pmu after reset?

Sneaky. Yes, that will work, just add a comment for the case where it
may fail (reset before batch execution).
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH i-g-t v2] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Chris Wilson]

Quoting Tvrtko Ursulin (2018-03-01 09:21:52)
> 
> On 01/03/2018 08:08, Chris Wilson wrote:
> > Quoting Tvrtko Ursulin (2018-02-28 17:15:19)
> >> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> >>
> >> Verify that the reported busyness is in line with what would we expect
> >> from a batch which causes a hang and gets kicked out from the engine.
> >>
> >> v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
> >>      batch will hang. (Chris Wilson)
> >>
> >> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> > 
> > It's nice and quick, yes. However, sometime the opposite is true and you
> > have to wait for the batch you want to start before pulling the trigger.
> > 
> > I'd put a usleep(100) in there /* Wait for batch to execute */ and we
> 
> Hm, but reset is triggered after the first sleep (which checks for 100% 
> busy). So even the non-hanging test flavour could be affect if the delay 
> before execution is so long. So by this logic this usleep(100) (or more 
> for small core CI) should then go to many tests. Only difference in the 
> hang flavour is that if it completely failed to run until after the 
> reset, then the idle assert would fail. So maybe I should just add an 
> assert that the batch is idle before sampling pmu after reset?

Sneaky. Yes, that will work, just add a comment for the case where it
may fail (reset before batch execution).
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[PATCH i-g-t v3] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

Verify that the reported busyness is in line with what would we expect
from a batch which causes a hang and gets kicked out from the engine.

v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
    batch will hang. (Chris Wilson)

v3: Assert and comment test expectations. (Chris Wilson)

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
---
 tests/perf_pmu.c | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
index 3bbb18d2f216..4713c98c5d22 100644
--- a/tests/perf_pmu.c
+++ b/tests/perf_pmu.c
@@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
 #define TEST_TRAILING_IDLE (4)
 #define TEST_RUNTIME_PM (8)
 #define FLAG_LONG (16)
+#define FLAG_HANG (32)
 
 static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 {
@@ -204,11 +205,35 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 		end_spin(gem_fd, spin, flags);
 	val = pmu_read_single(fd) - val;
 
-	end_spin(gem_fd, spin, FLAG_SYNC);
+	if (flags & FLAG_HANG)
+		igt_force_gpu_reset(gem_fd);
+	else
+		end_spin(gem_fd, spin, FLAG_SYNC);
+
+	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
+
+	/* Check for idle after hang. */
+	if (flags & FLAG_HANG) {
+		/* Sleep for a bit for reset unwind to settle. */
+		usleep(500e3);
+		/*
+		 * Ensure batch was executing before reset, meaning it must be
+		 * idle by now. Unless it did not even manage to start before we
+		 * triggered the reset, in which case the idleness check below
+		 * might fail. The latter is very unlikely since there are two
+		 * sleeps during which it had an opportunity to start.
+		 */
+		igt_assert(!gem_bo_busy(gem_fd, spin->handle));
+		val = pmu_read_single(fd);
+		slept = measured_usleep(batch_duration_ns / 1000);
+		val = pmu_read_single(fd) - val;
+
+		assert_within_epsilon(val, 0, tolerance);
+	}
+
 	igt_spin_batch_free(gem_fd, spin);
 	close(fd);
 
-	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
 	gem_quiescent_gpu(gem_fd);
 }
 
@@ -1690,6 +1715,9 @@ igt_main
 					      pct[i], e->name)
 					accuracy(fd, e, pct[i]);
 			}
+
+			igt_subtest_f("busy-hang-%s", e->name)
+				single(fd, e, TEST_BUSY | FLAG_HANG);
 		}
 
 		/**
-- 
2.14.1

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

[igt-dev] [PATCH i-g-t v3] tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

Verify that the reported busyness is in line with what would we expect
from a batch which causes a hang and gets kicked out from the engine.

v2: Change to explicit igt_force_gpu_reset instead of guessing when a spin
    batch will hang. (Chris Wilson)

v3: Assert and comment test expectations. (Chris Wilson)

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
---
 tests/perf_pmu.c | 32 ++++++++++++++++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/tests/perf_pmu.c b/tests/perf_pmu.c
index 3bbb18d2f216..4713c98c5d22 100644
--- a/tests/perf_pmu.c
+++ b/tests/perf_pmu.c
@@ -168,6 +168,7 @@ static unsigned int e2ring(int gem_fd, const struct intel_execution_engine2 *e)
 #define TEST_TRAILING_IDLE (4)
 #define TEST_RUNTIME_PM (8)
 #define FLAG_LONG (16)
+#define FLAG_HANG (32)
 
 static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
 {
@@ -204,11 +205,35 @@ single(int gem_fd, const struct intel_execution_engine2 *e, unsigned int flags)
 		end_spin(gem_fd, spin, flags);
 	val = pmu_read_single(fd) - val;
 
-	end_spin(gem_fd, spin, FLAG_SYNC);
+	if (flags & FLAG_HANG)
+		igt_force_gpu_reset(gem_fd);
+	else
+		end_spin(gem_fd, spin, FLAG_SYNC);
+
+	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
+
+	/* Check for idle after hang. */
+	if (flags & FLAG_HANG) {
+		/* Sleep for a bit for reset unwind to settle. */
+		usleep(500e3);
+		/*
+		 * Ensure batch was executing before reset, meaning it must be
+		 * idle by now. Unless it did not even manage to start before we
+		 * triggered the reset, in which case the idleness check below
+		 * might fail. The latter is very unlikely since there are two
+		 * sleeps during which it had an opportunity to start.
+		 */
+		igt_assert(!gem_bo_busy(gem_fd, spin->handle));
+		val = pmu_read_single(fd);
+		slept = measured_usleep(batch_duration_ns / 1000);
+		val = pmu_read_single(fd) - val;
+
+		assert_within_epsilon(val, 0, tolerance);
+	}
+
 	igt_spin_batch_free(gem_fd, spin);
 	close(fd);
 
-	assert_within_epsilon(val, flags & TEST_BUSY ? slept : 0.f, tolerance);
 	gem_quiescent_gpu(gem_fd);
 }
 
@@ -1690,6 +1715,9 @@ igt_main
 					      pct[i], e->name)
 					accuracy(fd, e, pct[i]);
 			}
+
+			igt_subtest_f("busy-hang-%s", e->name)
+				single(fd, e, TEST_BUSY | FLAG_HANG);
 		}
 
 		/**
-- 
2.14.1

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Patchwork]

== Series Details ==

Series: tests/perf_pmu: Test busyness reporting in face of GPU hangs
URL   : https://patchwork.freedesktop.org/series/38543/
State : success

== Summary ==

IGT patchset tested on top of latest successful build
6fc91dbb67eea6824100905a4ab1fb38f186dba0 perf_pmu: Fix some compile warnings with old compilers / 32-bit builds

with latest DRM-Tip kernel build CI_DRM_3800
92b39eb6f562 drm-tip: 2018y-02m-19d-15h-50m-23s UTC integration manifest

Testlist changes:
+igt@perf_pmu@busy-hang-bcs0
+igt@perf_pmu@busy-hang-rcs0
+igt@perf_pmu@busy-hang-vcs0
+igt@perf_pmu@busy-hang-vcs1
+igt@perf_pmu@busy-hang-vecs0

Test kms_pipe_crc_basic:
        Subgroup hang-read-crc-pipe-c:
                pass       -> FAIL       (fi-skl-6700k2) fdo#103191
        Subgroup suspend-read-crc-pipe-b:
                pass       -> INCOMPLETE (fi-snb-2520m) fdo#103713

fdo#103191 https://bugs.freedesktop.org/show_bug.cgi?id=103191
fdo#103713 https://bugs.freedesktop.org/show_bug.cgi?id=103713

fi-bdw-5557u     total:288  pass:267  dwarn:0   dfail:0   fail:0   skip:21  time:421s
fi-bdw-gvtdvm    total:288  pass:264  dwarn:0   dfail:0   fail:0   skip:24  time:431s
fi-blb-e6850     total:288  pass:223  dwarn:1   dfail:0   fail:0   skip:64  time:376s
fi-bsw-n3050     total:288  pass:242  dwarn:0   dfail:0   fail:0   skip:46  time:497s
fi-bwr-2160      total:288  pass:183  dwarn:0   dfail:0   fail:0   skip:105 time:289s
fi-bxt-dsi       total:288  pass:258  dwarn:0   dfail:0   fail:0   skip:30  time:485s
fi-bxt-j4205     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:487s
fi-byt-j1900     total:288  pass:253  dwarn:0   dfail:0   fail:0   skip:35  time:473s
fi-byt-n2820     total:288  pass:249  dwarn:0   dfail:0   fail:0   skip:39  time:469s
fi-cfl-s2        total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:570s
fi-cnl-y3        total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:587s
fi-elk-e7500     total:288  pass:229  dwarn:0   dfail:0   fail:0   skip:59  time:419s
fi-gdg-551       total:288  pass:179  dwarn:0   dfail:0   fail:1   skip:108 time:286s
fi-glk-1         total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:514s
fi-hsw-4770      total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:392s
fi-ilk-650       total:288  pass:228  dwarn:0   dfail:0   fail:0   skip:60  time:414s
fi-ivb-3520m     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:461s
fi-ivb-3770      total:288  pass:255  dwarn:0   dfail:0   fail:0   skip:33  time:413s
fi-kbl-7500u     total:288  pass:263  dwarn:1   dfail:0   fail:0   skip:24  time:457s
fi-kbl-7560u     total:288  pass:269  dwarn:0   dfail:0   fail:0   skip:19  time:497s
fi-kbl-7567u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:457s
fi-kbl-r         total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:500s
fi-pnv-d510      total:288  pass:222  dwarn:1   dfail:0   fail:0   skip:65  time:597s
fi-skl-6260u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:430s
fi-skl-6600u     total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:513s
fi-skl-6700hq    total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:527s
fi-skl-6700k2    total:288  pass:263  dwarn:0   dfail:0   fail:1   skip:24  time:498s
fi-skl-6770hq    total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:487s
fi-skl-guc       total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:416s
fi-skl-gvtdvm    total:288  pass:265  dwarn:0   dfail:0   fail:0   skip:23  time:431s
fi-snb-2520m     total:245  pass:211  dwarn:0   dfail:0   fail:0   skip:33 
fi-snb-2600      total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:403s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_954/issues.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.IGT: warning for tests/perf_pmu: Test busyness reporting in face of GPU hangs

[Patchwork]

== Series Details ==

Series: tests/perf_pmu: Test busyness reporting in face of GPU hangs
URL   : https://patchwork.freedesktop.org/series/38543/
State : warning

== Summary ==

Test pm_rc6_residency:
        Subgroup rc6-accuracy:
                pass       -> SKIP       (shard-snb)
Test kms_frontbuffer_tracking:
        Subgroup fbc-1p-primscrn-pri-indfb-draw-render:
                fail       -> PASS       (shard-snb) fdo#101623
Test kms_rotation_crc:
        Subgroup primary-rotation-180:
                pass       -> FAIL       (shard-snb) fdo#103925
Test perf:
        Subgroup oa-exponents:
                fail       -> PASS       (shard-apl) fdo#102254

fdo#101623 https://bugs.freedesktop.org/show_bug.cgi?id=101623
fdo#103925 https://bugs.freedesktop.org/show_bug.cgi?id=103925
fdo#102254 https://bugs.freedesktop.org/show_bug.cgi?id=102254

shard-apl        total:3343 pass:1743 dwarn:1   dfail:0   fail:16  skip:1582 time:12054s
shard-hsw        total:3439 pass:1765 dwarn:1   dfail:0   fail:3   skip:1669 time:11758s
shard-snb        total:3439 pass:1351 dwarn:1   dfail:0   fail:6   skip:2081 time:6726s
Blacklisted hosts:
shard-kbl        total:3439 pass:1926 dwarn:2   dfail:0   fail:16  skip:1494 time:9549s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_954/shards.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev2)

[Patchwork]

== Series Details ==

Series: tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev2)
URL   : https://patchwork.freedesktop.org/series/38543/
State : success

== Summary ==

IGT patchset tested on top of latest successful build
0d47ec161b4eca1b41c5348604aa05b105e5d1cf tests/perf: Fix build warning

with latest DRM-Tip kernel build CI_DRM_3850
573e919160e5 drm-tip: 2018y-02m-28d-16h-17m-37s UTC integration manifest

Testlist changes:
+igt@perf_pmu@busy-hang-bcs0
+igt@perf_pmu@busy-hang-rcs0
+igt@perf_pmu@busy-hang-vcs0
+igt@perf_pmu@busy-hang-vcs1
+igt@perf_pmu@busy-hang-vecs0

---- Known issues:

Test kms_pipe_crc_basic:
        Subgroup suspend-read-crc-pipe-b:
                pass       -> DMESG-WARN (fi-cnl-y3) fdo#104951

fdo#104951 https://bugs.freedesktop.org/show_bug.cgi?id=104951

fi-bdw-5557u     total:288  pass:267  dwarn:0   dfail:0   fail:0   skip:21  time:417s
fi-blb-e6850     total:288  pass:223  dwarn:1   dfail:0   fail:0   skip:64  time:375s
fi-bsw-n3050     total:288  pass:242  dwarn:0   dfail:0   fail:0   skip:46  time:486s
fi-bwr-2160      total:288  pass:183  dwarn:0   dfail:0   fail:0   skip:105 time:288s
fi-bxt-dsi       total:288  pass:258  dwarn:0   dfail:0   fail:0   skip:30  time:487s
fi-bxt-j4205     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:479s
fi-byt-j1900     total:288  pass:253  dwarn:0   dfail:0   fail:0   skip:35  time:468s
fi-byt-n2820     total:288  pass:249  dwarn:0   dfail:0   fail:0   skip:39  time:460s
fi-cfl-8700k     total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:395s
fi-cfl-s2        total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:561s
fi-cnl-y3        total:288  pass:261  dwarn:1   dfail:0   fail:0   skip:26  time:582s
fi-elk-e7500     total:288  pass:229  dwarn:0   dfail:0   fail:0   skip:59  time:410s
fi-gdg-551       total:288  pass:179  dwarn:0   dfail:0   fail:1   skip:108 time:289s
fi-glk-1         total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:507s
fi-hsw-4770      total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:386s
fi-ilk-650       total:288  pass:228  dwarn:0   dfail:0   fail:0   skip:60  time:410s
fi-ivb-3520m     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:442s
fi-ivb-3770      total:288  pass:255  dwarn:0   dfail:0   fail:0   skip:33  time:410s
fi-kbl-7500u     total:288  pass:263  dwarn:1   dfail:0   fail:0   skip:24  time:451s
fi-kbl-7560u     total:288  pass:269  dwarn:0   dfail:0   fail:0   skip:19  time:488s
fi-kbl-7567u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:450s
fi-kbl-r         total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:490s
fi-pnv-d510      total:288  pass:222  dwarn:1   dfail:0   fail:0   skip:65  time:586s
fi-skl-6260u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:431s
fi-skl-6600u     total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:501s
fi-skl-6700hq    total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:529s
fi-skl-6700k2    total:288  pass:264  dwarn:0   dfail:0   fail:0   skip:24  time:484s
fi-skl-6770hq    total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:478s
fi-skl-guc       total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:406s
fi-skl-gvtdvm    total:288  pass:265  dwarn:0   dfail:0   fail:0   skip:23  time:432s
fi-snb-2520m     total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:525s
fi-snb-2600      total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:391s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1027/issues.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.IGT: success for tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev2)

[Patchwork]

== Series Details ==

Series: tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev2)
URL   : https://patchwork.freedesktop.org/series/38543/
State : success

== Summary ==

---- Possible new issues:

Test kms_draw_crc:
        Subgroup draw-method-xrgb8888-mmap-cpu-xtiled:
                skip       -> PASS       (shard-snb)

---- Known issues:

Test kms_chv_cursor_fail:
        Subgroup pipe-b-256x256-right-edge:
                pass       -> DMESG-WARN (shard-snb) fdo#105185
Test kms_flip:
        Subgroup dpms-vs-vblank-race-interruptible:
                fail       -> PASS       (shard-hsw) fdo#103060
        Subgroup plain-flip-ts-check:
                fail       -> PASS       (shard-hsw) fdo#100368 +1
Test kms_rotation_crc:
        Subgroup primary-rotation-180:
                pass       -> FAIL       (shard-snb) fdo#103925
Test kms_sysfs_edid_timing:
                warn       -> PASS       (shard-apl) fdo#100047

fdo#105185 https://bugs.freedesktop.org/show_bug.cgi?id=105185
fdo#103060 https://bugs.freedesktop.org/show_bug.cgi?id=103060
fdo#100368 https://bugs.freedesktop.org/show_bug.cgi?id=100368
fdo#103925 https://bugs.freedesktop.org/show_bug.cgi?id=103925
fdo#100047 https://bugs.freedesktop.org/show_bug.cgi?id=100047

shard-apl        total:3465 pass:1824 dwarn:1   dfail:0   fail:7   skip:1633 time:12229s
shard-hsw        total:3465 pass:1771 dwarn:1   dfail:0   fail:1   skip:1691 time:11689s
shard-snb        total:3465 pass:1360 dwarn:2   dfail:0   fail:2   skip:2101 time:6654s
Blacklisted hosts:
shard-kbl        total:3404 pass:1910 dwarn:1   dfail:0   fail:7   skip:1485 time:9177s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1027/shards.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev3)

[Patchwork]

== Series Details ==

Series: tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev3)
URL   : https://patchwork.freedesktop.org/series/38543/
State : success

== Summary ==

IGT patchset tested on top of latest successful build
6a06d014a38fc8282f7dda7c11e5cacd9daf44ca lib: Provide an accelerated routine for readback from WC

with latest DRM-Tip kernel build CI_DRM_3854
f12b759446c4 drm-tip: 2018y-03m-01d-07h-28m-47s UTC integration manifest

Testlist changes:
+igt@perf_pmu@busy-hang-bcs0
+igt@perf_pmu@busy-hang-rcs0
+igt@perf_pmu@busy-hang-vcs0
+igt@perf_pmu@busy-hang-vcs1
+igt@perf_pmu@busy-hang-vecs0

---- Known issues:

Test kms_busy:
        Subgroup basic-flip-b:
                fail       -> PASS       (fi-elk-e7500) fdo#103989

fdo#103989 https://bugs.freedesktop.org/show_bug.cgi?id=103989

fi-bdw-5557u     total:288  pass:267  dwarn:0   dfail:0   fail:0   skip:21  time:414s
fi-bdw-gvtdvm    total:288  pass:264  dwarn:0   dfail:0   fail:0   skip:24  time:422s
fi-blb-e6850     total:288  pass:223  dwarn:1   dfail:0   fail:0   skip:64  time:374s
fi-bsw-n3050     total:288  pass:242  dwarn:0   dfail:0   fail:0   skip:46  time:486s
fi-bwr-2160      total:288  pass:183  dwarn:0   dfail:0   fail:0   skip:105 time:280s
fi-bxt-dsi       total:288  pass:258  dwarn:0   dfail:0   fail:0   skip:30  time:481s
fi-bxt-j4205     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:486s
fi-byt-j1900     total:288  pass:253  dwarn:0   dfail:0   fail:0   skip:35  time:469s
fi-byt-n2820     total:288  pass:249  dwarn:0   dfail:0   fail:0   skip:39  time:467s
fi-cfl-8700k     total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:391s
fi-cfl-s2        total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:563s
fi-elk-e7500     total:288  pass:229  dwarn:0   dfail:0   fail:0   skip:59  time:412s
fi-gdg-551       total:288  pass:179  dwarn:0   dfail:0   fail:1   skip:108 time:291s
fi-glk-1         total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:506s
fi-hsw-4770      total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:385s
fi-ilk-650       total:288  pass:228  dwarn:0   dfail:0   fail:0   skip:60  time:412s
fi-ivb-3520m     total:288  pass:259  dwarn:0   dfail:0   fail:0   skip:29  time:449s
fi-ivb-3770      total:288  pass:255  dwarn:0   dfail:0   fail:0   skip:33  time:413s
fi-kbl-7500u     total:288  pass:263  dwarn:1   dfail:0   fail:0   skip:24  time:452s
fi-kbl-7560u     total:288  pass:269  dwarn:0   dfail:0   fail:0   skip:19  time:491s
fi-kbl-7567u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:449s
fi-kbl-r         total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:494s
fi-pnv-d510      total:288  pass:222  dwarn:1   dfail:0   fail:0   skip:65  time:587s
fi-skl-6260u     total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:422s
fi-skl-6600u     total:288  pass:261  dwarn:0   dfail:0   fail:0   skip:27  time:502s
fi-skl-6700hq    total:288  pass:262  dwarn:0   dfail:0   fail:0   skip:26  time:522s
fi-skl-6700k2    total:288  pass:264  dwarn:0   dfail:0   fail:0   skip:24  time:493s
fi-skl-6770hq    total:288  pass:268  dwarn:0   dfail:0   fail:0   skip:20  time:477s
fi-skl-guc       total:288  pass:260  dwarn:0   dfail:0   fail:0   skip:28  time:408s
fi-snb-2520m     total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:527s
fi-snb-2600      total:288  pass:248  dwarn:0   dfail:0   fail:0   skip:40  time:396s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1032/issues.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.IGT: warning for tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev3)

[Patchwork]

== Series Details ==

Series: tests/perf_pmu: Test busyness reporting in face of GPU hangs (rev3)
URL   : https://patchwork.freedesktop.org/series/38543/
State : warning

== Summary ==

---- Possible new issues:

Test gem_tiled_blits:
        Subgroup interruptible:
                pass       -> SKIP       (shard-apl)

---- Known issues:

Test gem_eio:
        Subgroup in-flight:
                incomplete -> PASS       (shard-apl) fdo#104945 +1
Test gem_partial_pwrite_pread:
        Subgroup write-snoop:
                incomplete -> PASS       (shard-hsw) fdo#103540
Test kms_chv_cursor_fail:
        Subgroup pipe-b-64x64-right-edge:
                dmesg-warn -> PASS       (shard-snb) fdo#105185
Test kms_flip:
        Subgroup 2x-plain-flip-fb-recreate-interruptible:
                pass       -> FAIL       (shard-hsw) fdo#100368 +1
        Subgroup flip-vs-expired-vblank-interruptible:
                fail       -> PASS       (shard-hsw) fdo#102887
Test kms_rotation_crc:
        Subgroup primary-rotation-180:
                pass       -> FAIL       (shard-snb) fdo#103925
Test perf:
        Subgroup enable-disable:
                fail       -> PASS       (shard-apl) fdo#103715
        Subgroup oa-exponents:
                pass       -> INCOMPLETE (shard-apl) fdo#102254

fdo#104945 https://bugs.freedesktop.org/show_bug.cgi?id=104945
fdo#103540 https://bugs.freedesktop.org/show_bug.cgi?id=103540
fdo#105185 https://bugs.freedesktop.org/show_bug.cgi?id=105185
fdo#100368 https://bugs.freedesktop.org/show_bug.cgi?id=100368
fdo#102887 https://bugs.freedesktop.org/show_bug.cgi?id=102887
fdo#103925 https://bugs.freedesktop.org/show_bug.cgi?id=103925
fdo#103715 https://bugs.freedesktop.org/show_bug.cgi?id=103715
fdo#102254 https://bugs.freedesktop.org/show_bug.cgi?id=102254

shard-apl        total:3348 pass:1760 dwarn:1   dfail:0   fail:7   skip:1577 time:11412s
shard-hsw        total:3418 pass:1747 dwarn:1   dfail:0   fail:3   skip:1665 time:11207s
shard-snb        total:3465 pass:1361 dwarn:1   dfail:0   fail:2   skip:2101 time:6625s
Blacklisted hosts:
shard-kbl        total:3447 pass:1929 dwarn:1   dfail:0   fail:7   skip:1509 time:9177s

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_1032/shards.html
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev