[igt-dev] [PATCH v3 0/2] New subtest for VRR Flipline mode

[igt-dev] [PATCH v3 0/2] New subtest for VRR Flipline mode

[Bhanuprakash Modem]

To validate Adaptive-Sync's Flipline mode, make sure that flips happen at
flipline decision boundary.

Example: if monitor vrr range is 40 - 60Hz and

* flip at refresh_rate > 60Hz:
        Flip should happen at the flipline boundary & returned refresh rate
        would be 60Hz.
* flip at refresh_rate == 50Hz:
        Flip should happen right away so returned refresh rate is 50Hz.
* flip at refresh_rate < 40Hz:
        Flip should happen at the vmax so the returned refresh rate
        would be 40Hz.

Bhanuprakash Modem (2):
  tests/kms_vrr: Use atomic API for page flip
  tests/kms_vrr: Add new subtest to validate Flipline mode

 tests/kms_vrr.c | 163 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 108 insertions(+), 55 deletions(-)

--
2.20.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 New subtest for VRR Flipline mode (rev4)

[Patchwork]

[-- Attachment #1.1: Type: text/plain, Size: 5359 bytes --]

== Series Details ==

Series: New subtest for VRR Flipline mode (rev4)
URL   : https://patchwork.freedesktop.org/series/77128/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_8909 -> IGTPW_4896
====================================================

Summary
-------

  **WARNING**

  Minor unknown changes coming with IGTPW_4896 need to be verified
  manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_4896, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/index.html

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in IGTPW_4896:

### IGT changes ###

#### Warnings ####

  * igt@runner@aborted:
    - fi-tgl-u2:          [FAIL][1] ([i915#1233] / [i915#2110]) -> [FAIL][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-tgl-u2/igt@runner@aborted.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-tgl-u2/igt@runner@aborted.html

  
Known issues
------------

  Here are the changes found in IGTPW_4896 that come from known issues:

### IGT changes ###

#### Possible fixes ####

  * igt@i915_selftest@live@execlists:
    - fi-kbl-guc:         [INCOMPLETE][3] ([i915#794]) -> [PASS][4]
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-kbl-guc/igt@i915_selftest@live@execlists.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-kbl-guc/igt@i915_selftest@live@execlists.html

  * igt@i915_selftest@live@gt_lrc:
    - fi-tgl-u2:          [DMESG-FAIL][5] ([i915#1233]) -> [PASS][6]
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-tgl-u2/igt@i915_selftest@live@gt_lrc.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-tgl-u2/igt@i915_selftest@live@gt_lrc.html

  * igt@kms_cursor_legacy@basic-busy-flip-before-cursor-atomic:
    - fi-bsw-n3050:       [DMESG-WARN][7] ([i915#1982]) -> [PASS][8]
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-bsw-n3050/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-atomic.html
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-bsw-n3050/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-atomic.html
    - fi-byt-j1900:       [DMESG-WARN][9] ([i915#1982]) -> [PASS][10] +1 similar issue
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-byt-j1900/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-atomic.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-byt-j1900/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-atomic.html

  * igt@kms_flip@basic-flip-vs-wf_vblank@c-dp2:
    - fi-skl-guc:         [DMESG-WARN][11] ([i915#2203]) -> [PASS][12] +1 similar issue
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-skl-guc/igt@kms_flip@basic-flip-vs-wf_vblank@c-dp2.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-skl-guc/igt@kms_flip@basic-flip-vs-wf_vblank@c-dp2.html

  
#### Warnings ####

  * igt@kms_flip@basic-flip-vs-wf_vblank@a-dp1:
    - fi-kbl-x1275:       [DMESG-WARN][13] ([i915#62] / [i915#92] / [i915#95]) -> [DMESG-WARN][14] ([i915#62] / [i915#92]) +4 similar issues
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-kbl-x1275/igt@kms_flip@basic-flip-vs-wf_vblank@a-dp1.html
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-kbl-x1275/igt@kms_flip@basic-flip-vs-wf_vblank@a-dp1.html

  * igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a:
    - fi-kbl-x1275:       [DMESG-WARN][15] ([i915#62] / [i915#92]) -> [DMESG-WARN][16] ([i915#62] / [i915#92] / [i915#95]) +4 similar issues
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/fi-kbl-x1275/igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/fi-kbl-x1275/igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [i915#1233]: https://gitlab.freedesktop.org/drm/intel/issues/1233
  [i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
  [i915#2110]: https://gitlab.freedesktop.org/drm/intel/issues/2110
  [i915#2203]: https://gitlab.freedesktop.org/drm/intel/issues/2203
  [i915#62]: https://gitlab.freedesktop.org/drm/intel/issues/62
  [i915#794]: https://gitlab.freedesktop.org/drm/intel/issues/794
  [i915#92]: https://gitlab.freedesktop.org/drm/intel/issues/92
  [i915#95]: https://gitlab.freedesktop.org/drm/intel/issues/95


Participating hosts (39 -> 34)
------------------------------

  Missing    (5): fi-ilk-m540 fi-hsw-4200u fi-byt-squawks fi-bsw-cyan fi-byt-clapper 


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_5769 -> IGTPW_4896

  CI-20190529: 20190529
  CI_DRM_8909: 1939e049a8ec6cef03a098f7cc99cb0bbcff21c6 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_4896: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/index.html
  IGT_5769: 4e5f76be680b65780204668e302026cf638decc9 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools



== Testlist changes ==

+igt@kms_vrr@flipline

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/index.html

[-- Attachment #1.2: Type: text/html, Size: 6748 bytes --]

[-- Attachment #2: Type: text/plain, Size: 154 bytes --]

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

[igt-dev] [PATCH v3 1/2] tests/kms_vrr: Use atomic API for page flip

[Bhanuprakash Modem]

We should avoid using drmModePageFlip as it'll only be used for
legacy drivers, instead, use igt_display_commit_atomic() API to
page flip for atomic display code path.

v2:
* Look for the page flip event not for the vblank event (Nicholas)
* Fix to flip with different FBs (Bhanu)
v3:
* s/get_vblank_event_ns/get_kernel_event_ns/ (Manasi)
* Add a comment to capture the flip event (Manasi)
* Make sure we are reading valid event (Bhanu)
* Test clean-up (Bhanu)

Cc: Harry Wentland <harry.wentland@amd.com>
Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
---
 tests/kms_vrr.c | 66 +++++++++++++++++++++++++------------------------
 1 file changed, 34 insertions(+), 32 deletions(-)

diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
index a0db90006d..15db7695e8 100644
--- a/tests/kms_vrr.c
+++ b/tests/kms_vrr.c
@@ -47,6 +47,7 @@ typedef struct range {
 typedef struct data {
 	igt_display_t display;
 	int drm_fd;
+	igt_plane_t *primary;
 	igt_fb_t fb0;
 	igt_fb_t fb1;
 } data_t;
@@ -60,15 +61,18 @@ static uint64_t timespec_to_ns(struct timespec *ts)
 }
 
 /*
- * Gets a vblank event from DRM and returns its timestamp in nanoseconds.
+ * Gets an event from DRM and returns its timestamp in nanoseconds.
+ * Asserts if the event from DRM is not matched with requested one.
+ *
  * This blocks until the event is received.
  */
-static uint64_t get_vblank_event_ns(data_t *data)
+static uint64_t get_kernel_event_ns(data_t *data, uint32_t event)
 {
 	struct drm_event_vblank ev;
 
-	igt_set_timeout(1, "Waiting for vblank event\n");
+	igt_set_timeout(1, "Waiting for an event\n");
 	igt_assert_eq(read(data->drm_fd, &ev, sizeof(ev)), sizeof(ev));
+	igt_assert_eq(ev.base.type, event);
 	igt_reset_timeout();
 
 	return ev.tv_sec * NSECS_PER_SEC + ev.tv_usec * 1000ull;
@@ -126,11 +130,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
 }
 
 /* Returns a suitable vrr test frequency. */
-static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
+static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
 {
 	drmModeModeInfo *mode = igt_output_get_mode(output);
 	range_t range;
-	uint32_t vtest;
+	uint64_t vtest;
 
 	/*
 	 * The frequency with the fastest convergence speed should be
@@ -165,7 +169,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe pipe, bool enabled)
 static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
 {
 	drmModeModeInfo mode = *igt_output_get_mode(output);
-	igt_plane_t *primary;
 	cairo_t *cr;
 
 	/* Reset output */
@@ -189,8 +192,8 @@ static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
 	igt_put_cairo_ctx(cr);
 
 	/* Take care of any required modesetting before the test begins. */
-	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
-	igt_plane_set_fb(primary, &data->fb0);
+	data->primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
+	igt_plane_set_fb(data->primary, &data->fb0);
 
 	igt_display_commit_atomic(&data->display,
 				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
@@ -207,35 +210,28 @@ wait_for_vblank(data_t *data, enum pipe pipe)
 	vbl.request.sequence = 1;
 	drmWaitVBlank(data->drm_fd, &vbl);
 
-	return get_vblank_event_ns(data);
+	return get_kernel_event_ns(data, DRM_EVENT_VBLANK);
 }
 
-/* Performs an asynchronous non-blocking page-flip on a pipe. */
-static int
-do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
+/* Performs an atomic non-blocking page-flip on a pipe. */
+static void
+do_flip(data_t *data, igt_fb_t *fb)
 {
-	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
 	int ret;
 
 	igt_set_timeout(1, "Scheduling page flip\n");
 
-	/*
-	 * Only the legacy flip ioctl supports async flips.
-	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
-	 * 2x monitor tests will need async flips in the atomic API.
-	 */
+	igt_plane_set_fb(data->primary, fb);
+
 	do {
-		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
-				      fb->fb_id,
-				      DRM_MODE_PAGE_FLIP_EVENT |
-				      DRM_MODE_PAGE_FLIP_ASYNC,
-				      data);
+		ret = igt_display_try_commit_atomic(&data->display,
+				  DRM_MODE_ATOMIC_NONBLOCK |
+				  DRM_MODE_PAGE_FLIP_EVENT,
+				  data);
 	} while (ret == -EBUSY);
 
 	igt_assert_eq(ret, 0);
 	igt_reset_timeout();
-
-	return 0;
 }
 
 /*
@@ -246,11 +242,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
  * can arbitrarily restrict the bounds further than the absolute
  * min and max range. But VRR is really about extending the flip
  * to prevent stuttering or to match a source content rate.
- *
- * The only way to "present" at a fixed rate like userspace in a vendor
- * neutral manner is to do it with async flips. This avoids the need
- * to wait for next vblank and it should eventually converge at the
- * desired rate.
  */
 static uint32_t
 flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
@@ -269,9 +260,14 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		int64_t diff_ns;
 
 		front = !front;
-		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
+		do_flip(data, front ? &data->fb1 : &data->fb0);
 
-		vblank_ns = get_vblank_event_ns(data);
+		/* We need to cpture flip event instead of vblank event,
+		 * because vblank is triggered after each frame, but depending
+		 * on the vblank evasion time flip might or might not happen in
+		 * that same frame.
+		 */
+		vblank_ns = get_kernel_event_ns(data, DRM_EVENT_FLIP_COMPLETE);
 		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
 		last_vblank_ns = vblank_ns;
 
@@ -359,6 +355,12 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 		     "Target VRR off threshold exceeded, result was %u%%\n",
 		     result);
 
+	/* Clean-up */
+	igt_plane_set_fb(data->primary, NULL);
+	igt_output_set_pipe(output, PIPE_NONE);
+	igt_display_commit_atomic(&data->display,
+				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+
 	igt_remove_fb(data->drm_fd, &data->fb1);
 	igt_remove_fb(data->drm_fd, &data->fb0);
 }
-- 
2.20.1

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

Re: [igt-dev] [PATCH v3 1/2] tests/kms_vrr: Use atomic API for page flip

[Navare, Manasi]

On Thu, Aug 20, 2020 at 10:12:47PM +0530, Bhanuprakash Modem wrote:
> We should avoid using drmModePageFlip as it'll only be used for
> legacy drivers, instead, use igt_display_commit_atomic() API to
> page flip for atomic display code path.
> 
> v2:
> * Look for the page flip event not for the vblank event (Nicholas)
> * Fix to flip with different FBs (Bhanu)
> v3:
> * s/get_vblank_event_ns/get_kernel_event_ns/ (Manasi)
> * Add a comment to capture the flip event (Manasi)
> * Make sure we are reading valid event (Bhanu)
> * Test clean-up (Bhanu)
> 
> Cc: Harry Wentland <harry.wentland@amd.com>
> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> Cc: Manasi Navare <manasi.d.navare@intel.com>
> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> ---
>  tests/kms_vrr.c | 66 +++++++++++++++++++++++++------------------------
>  1 file changed, 34 insertions(+), 32 deletions(-)
> 
> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> index a0db90006d..15db7695e8 100644
> --- a/tests/kms_vrr.c
> +++ b/tests/kms_vrr.c
> @@ -47,6 +47,7 @@ typedef struct range {
>  typedef struct data {
>  	igt_display_t display;
>  	int drm_fd;
> +	igt_plane_t *primary;
>  	igt_fb_t fb0;
>  	igt_fb_t fb1;
>  } data_t;
> @@ -60,15 +61,18 @@ static uint64_t timespec_to_ns(struct timespec *ts)
>  }
>  
>  /*
> - * Gets a vblank event from DRM and returns its timestamp in nanoseconds.
> + * Gets an event from DRM and returns its timestamp in nanoseconds.
> + * Asserts if the event from DRM is not matched with requested one.
> + *
>   * This blocks until the event is received.
>   */
> -static uint64_t get_vblank_event_ns(data_t *data)
> +static uint64_t get_kernel_event_ns(data_t *data, uint32_t event)
>  {
>  	struct drm_event_vblank ev;
>  
> -	igt_set_timeout(1, "Waiting for vblank event\n");
> +	igt_set_timeout(1, "Waiting for an event\n");
>  	igt_assert_eq(read(data->drm_fd, &ev, sizeof(ev)), sizeof(ev));
> +	igt_assert_eq(ev.base.type, event);
>  	igt_reset_timeout();
>  
>  	return ev.tv_sec * NSECS_PER_SEC + ev.tv_usec * 1000ull;
> @@ -126,11 +130,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
>  }
>  
>  /* Returns a suitable vrr test frequency. */
> -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
>  {
>  	drmModeModeInfo *mode = igt_output_get_mode(output);
>  	range_t range;
> -	uint32_t vtest;
> +	uint64_t vtest;
>  
>  	/*
>  	 * The frequency with the fastest convergence speed should be
> @@ -165,7 +169,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe pipe, bool enabled)
>  static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
>  {
>  	drmModeModeInfo mode = *igt_output_get_mode(output);
> -	igt_plane_t *primary;
>  	cairo_t *cr;
>  
>  	/* Reset output */
> @@ -189,8 +192,8 @@ static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
>  	igt_put_cairo_ctx(cr);
>  
>  	/* Take care of any required modesetting before the test begins. */
> -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> -	igt_plane_set_fb(primary, &data->fb0);
> +	data->primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> +	igt_plane_set_fb(data->primary, &data->fb0);
>  
>  	igt_display_commit_atomic(&data->display,
>  				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> @@ -207,35 +210,28 @@ wait_for_vblank(data_t *data, enum pipe pipe)
>  	vbl.request.sequence = 1;
>  	drmWaitVBlank(data->drm_fd, &vbl);
>  
> -	return get_vblank_event_ns(data);
> +	return get_kernel_event_ns(data, DRM_EVENT_VBLANK);
>  }
>  
> -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> -static int
> -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> +/* Performs an atomic non-blocking page-flip on a pipe. */
> +static void
> +do_flip(data_t *data, igt_fb_t *fb)
>  {
> -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
>  	int ret;
>  
>  	igt_set_timeout(1, "Scheduling page flip\n");
>  
> -	/*
> -	 * Only the legacy flip ioctl supports async flips.
> -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> -	 * 2x monitor tests will need async flips in the atomic API.
> -	 */
> +	igt_plane_set_fb(data->primary, fb);
> +
>  	do {
> -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> -				      fb->fb_id,
> -				      DRM_MODE_PAGE_FLIP_EVENT |
> -				      DRM_MODE_PAGE_FLIP_ASYNC,
> -				      data);
> +		ret = igt_display_try_commit_atomic(&data->display,
> +				  DRM_MODE_ATOMIC_NONBLOCK |
> +				  DRM_MODE_PAGE_FLIP_EVENT,
> +				  data);
>  	} while (ret == -EBUSY);
>  
>  	igt_assert_eq(ret, 0);
>  	igt_reset_timeout();
> -
> -	return 0;
>  }
>  
>  /*
> @@ -246,11 +242,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
>   * can arbitrarily restrict the bounds further than the absolute
>   * min and max range. But VRR is really about extending the flip
>   * to prevent stuttering or to match a source content rate.
> - *
> - * The only way to "present" at a fixed rate like userspace in a vendor
> - * neutral manner is to do it with async flips. This avoids the need
> - * to wait for next vblank and it should eventually converge at the
> - * desired rate.
>   */
>  static uint32_t
>  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> @@ -269,9 +260,14 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>  		int64_t diff_ns;
>  
>  		front = !front;
> -		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> +		do_flip(data, front ? &data->fb1 : &data->fb0);
>  
> -		vblank_ns = get_vblank_event_ns(data);
> +		/* We need to cpture flip event instead of vblank event,
		            ^^capture

> +		 * because vblank is triggered after each frame, but depending
> +		 * on the vblank evasion time flip might or might not happen in
> +		 * that same frame.
> +		 */
> +		vblank_ns = get_kernel_event_ns(data, DRM_EVENT_FLIP_COMPLETE);
Does it make sense to name this as event_ns, calling it vbalnk_ns makes it little
confusing since in the explanation, we said we are capture flip event here?

Not a hard change requested, but just a suggestion.

Regards
Manasi

>  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
>  		last_vblank_ns = vblank_ns;
>  
> @@ -359,6 +355,12 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>  		     "Target VRR off threshold exceeded, result was %u%%\n",
>  		     result);
>  
> +	/* Clean-up */
> +	igt_plane_set_fb(data->primary, NULL);
> +	igt_output_set_pipe(output, PIPE_NONE);
> +	igt_display_commit_atomic(&data->display,
> +				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> +
>  	igt_remove_fb(data->drm_fd, &data->fb1);
>  	igt_remove_fb(data->drm_fd, &data->fb0);
>  }
> -- 
> 2.20.1
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH v3 1/2] tests/kms_vrr: Use atomic API for page flip

[Navare, Manasi]

On Thu, Aug 20, 2020 at 11:23:47AM -0700, Navare, Manasi wrote:
> On Thu, Aug 20, 2020 at 10:12:47PM +0530, Bhanuprakash Modem wrote:
> > We should avoid using drmModePageFlip as it'll only be used for
> > legacy drivers, instead, use igt_display_commit_atomic() API to
> > page flip for atomic display code path.
> > 
> > v2:
> > * Look for the page flip event not for the vblank event (Nicholas)
> > * Fix to flip with different FBs (Bhanu)
> > v3:
> > * s/get_vblank_event_ns/get_kernel_event_ns/ (Manasi)
> > * Add a comment to capture the flip event (Manasi)
> > * Make sure we are reading valid event (Bhanu)
> > * Test clean-up (Bhanu)
> > 
> > Cc: Harry Wentland <harry.wentland@amd.com>
> > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> > ---
> >  tests/kms_vrr.c | 66 +++++++++++++++++++++++++------------------------
> >  1 file changed, 34 insertions(+), 32 deletions(-)
> > 
> > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > index a0db90006d..15db7695e8 100644
> > --- a/tests/kms_vrr.c
> > +++ b/tests/kms_vrr.c
> > @@ -47,6 +47,7 @@ typedef struct range {
> >  typedef struct data {
> >  	igt_display_t display;
> >  	int drm_fd;
> > +	igt_plane_t *primary;
> >  	igt_fb_t fb0;
> >  	igt_fb_t fb1;
> >  } data_t;
> > @@ -60,15 +61,18 @@ static uint64_t timespec_to_ns(struct timespec *ts)
> >  }
> >  
> >  /*
> > - * Gets a vblank event from DRM and returns its timestamp in nanoseconds.
> > + * Gets an event from DRM and returns its timestamp in nanoseconds.
> > + * Asserts if the event from DRM is not matched with requested one.
> > + *
> >   * This blocks until the event is received.
> >   */
> > -static uint64_t get_vblank_event_ns(data_t *data)
> > +static uint64_t get_kernel_event_ns(data_t *data, uint32_t event)
> >  {
> >  	struct drm_event_vblank ev;
> >  
> > -	igt_set_timeout(1, "Waiting for vblank event\n");
> > +	igt_set_timeout(1, "Waiting for an event\n");
> >  	igt_assert_eq(read(data->drm_fd, &ev, sizeof(ev)), sizeof(ev));
> > +	igt_assert_eq(ev.base.type, event);
> >  	igt_reset_timeout();
> >  
> >  	return ev.tv_sec * NSECS_PER_SEC + ev.tv_usec * 1000ull;
> > @@ -126,11 +130,11 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
> >  }
> >  
> >  /* Returns a suitable vrr test frequency. */
> > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> >  {
> >  	drmModeModeInfo *mode = igt_output_get_mode(output);
> >  	range_t range;
> > -	uint32_t vtest;
> > +	uint64_t vtest;
> >  
> >  	/*
> >  	 * The frequency with the fastest convergence speed should be
> > @@ -165,7 +169,6 @@ static void set_vrr_on_pipe(data_t *data, enum pipe pipe, bool enabled)
> >  static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
> >  {
> >  	drmModeModeInfo mode = *igt_output_get_mode(output);
> > -	igt_plane_t *primary;
> >  	cairo_t *cr;
> >  
> >  	/* Reset output */
> > @@ -189,8 +192,8 @@ static void prepare_test(data_t *data, igt_output_t *output, enum pipe pipe)
> >  	igt_put_cairo_ctx(cr);
> >  
> >  	/* Take care of any required modesetting before the test begins. */
> > -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> > -	igt_plane_set_fb(primary, &data->fb0);
> > +	data->primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> > +	igt_plane_set_fb(data->primary, &data->fb0);
> >  
> >  	igt_display_commit_atomic(&data->display,
> >  				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > @@ -207,35 +210,28 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> >  	vbl.request.sequence = 1;
> >  	drmWaitVBlank(data->drm_fd, &vbl);
> >  
> > -	return get_vblank_event_ns(data);
> > +	return get_kernel_event_ns(data, DRM_EVENT_VBLANK);
> >  }
> >  
> > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > -static int
> > -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > +static void
> > +do_flip(data_t *data, igt_fb_t *fb)
> >  {
> > -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> >  	int ret;
> >  
> >  	igt_set_timeout(1, "Scheduling page flip\n");
> >  
> > -	/*
> > -	 * Only the legacy flip ioctl supports async flips.
> > -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > -	 * 2x monitor tests will need async flips in the atomic API.
> > -	 */
> > +	igt_plane_set_fb(data->primary, fb);
> > +
> >  	do {
> > -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > -				      fb->fb_id,
> > -				      DRM_MODE_PAGE_FLIP_EVENT |
> > -				      DRM_MODE_PAGE_FLIP_ASYNC,
> > -				      data);
> > +		ret = igt_display_try_commit_atomic(&data->display,
> > +				  DRM_MODE_ATOMIC_NONBLOCK |
> > +				  DRM_MODE_PAGE_FLIP_EVENT,
> > +				  data);

Why do we need to use igt_display_try_commit_atomic() and not just
igt_display_commit_atomic()?

Also in set_vrr_on_pipe() function, I would prefer using
igt_display_commit2() call.
And IMO, the set_vrr_on_pipe() should be called before prepare_test()
since the prop needs to be set before the modeset request.

The other think that I had to change was reset vrr prop, then set it and then prepare_test
so:

set_vrr_on_pipe(data, pipe, 0)
set_vrr_on_pipe(data, pipe, 1)
prepare_test()

This is needed since the driver doesnt do a full modeset if old_crtc_state.vrr_enabled == new_crtc_state.vrr_enabled

Manasi

> >  	} while (ret == -EBUSY);
> >  
> >  	igt_assert_eq(ret, 0);
> >  	igt_reset_timeout();
> > -
> > -	return 0;
> >  }
> >  
> >  /*
> > @@ -246,11 +242,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> >   * can arbitrarily restrict the bounds further than the absolute
> >   * min and max range. But VRR is really about extending the flip
> >   * to prevent stuttering or to match a source content rate.
> > - *
> > - * The only way to "present" at a fixed rate like userspace in a vendor
> > - * neutral manner is to do it with async flips. This avoids the need
> > - * to wait for next vblank and it should eventually converge at the
> > - * desired rate.
> >   */
> >  static uint32_t
> >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> > @@ -269,9 +260,14 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> >  		int64_t diff_ns;
> >  
> >  		front = !front;
> > -		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> > +		do_flip(data, front ? &data->fb1 : &data->fb0);
> >  
> > -		vblank_ns = get_vblank_event_ns(data);
> > +		/* We need to cpture flip event instead of vblank event,
> 		            ^^capture
> 
> > +		 * because vblank is triggered after each frame, but depending
> > +		 * on the vblank evasion time flip might or might not happen in
> > +		 * that same frame.
> > +		 */
> > +		vblank_ns = get_kernel_event_ns(data, DRM_EVENT_FLIP_COMPLETE);
> Does it make sense to name this as event_ns, calling it vbalnk_ns makes it little
> confusing since in the explanation, we said we are capture flip event here?
> 
> Not a hard change requested, but just a suggestion.
> 
> Regards
> Manasi
> 
> >  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> >  		last_vblank_ns = vblank_ns;
> >  
> > @@ -359,6 +355,12 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
> >  		     "Target VRR off threshold exceeded, result was %u%%\n",
> >  		     result);
> >  
> > +	/* Clean-up */
> > +	igt_plane_set_fb(data->primary, NULL);
> > +	igt_output_set_pipe(output, PIPE_NONE);
> > +	igt_display_commit_atomic(&data->display,
> > +				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > +
> >  	igt_remove_fb(data->drm_fd, &data->fb1);
> >  	igt_remove_fb(data->drm_fd, &data->fb0);
> >  }
> > -- 
> > 2.20.1
> > 
> _______________________________________________
> igt-dev mailing list
> igt-dev@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/igt-dev
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH v3 1/2] tests/kms_vrr: Use atomic API for page flip

[Modem, Bhanuprakash]

> -----Original Message-----
> From: Navare, Manasi <manasi.d.navare@intel.com>
> Sent: Wednesday, August 26, 2020 2:41 AM
> To: Modem, Bhanuprakash <bhanuprakash.modem@intel.com>
> Cc: igt-dev@lists.freedesktop.org
> Subject: Re: [igt-dev] [PATCH v3 1/2] tests/kms_vrr: Use atomic API for
> page flip
> 
> On Thu, Aug 20, 2020 at 11:23:47AM -0700, Navare, Manasi wrote:
> > On Thu, Aug 20, 2020 at 10:12:47PM +0530, Bhanuprakash Modem wrote:
> > > We should avoid using drmModePageFlip as it'll only be used for
> > > legacy drivers, instead, use igt_display_commit_atomic() API to
> > > page flip for atomic display code path.
> > >
> > > v2:
> > > * Look for the page flip event not for the vblank event (Nicholas)
> > > * Fix to flip with different FBs (Bhanu)
> > > v3:
> > > * s/get_vblank_event_ns/get_kernel_event_ns/ (Manasi)
> > > * Add a comment to capture the flip event (Manasi)
> > > * Make sure we are reading valid event (Bhanu)
> > > * Test clean-up (Bhanu)
> > >
> > > Cc: Harry Wentland <harry.wentland@amd.com>
> > > Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> > > Cc: Manasi Navare <manasi.d.navare@intel.com>
> > > Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> > > ---
> > >  tests/kms_vrr.c | 66 +++++++++++++++++++++++++-----------------------
> -
> > >  1 file changed, 34 insertions(+), 32 deletions(-)
> > >
> > > diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> > > index a0db90006d..15db7695e8 100644
> > > --- a/tests/kms_vrr.c
> > > +++ b/tests/kms_vrr.c
> > > @@ -47,6 +47,7 @@ typedef struct range {
> > >  typedef struct data {
> > >  	igt_display_t display;
> > >  	int drm_fd;
> > > +	igt_plane_t *primary;
> > >  	igt_fb_t fb0;
> > >  	igt_fb_t fb1;
> > >  } data_t;
> > > @@ -60,15 +61,18 @@ static uint64_t timespec_to_ns(struct timespec
> *ts)
> > >  }
> > >
> > >  /*
> > > - * Gets a vblank event from DRM and returns its timestamp in
> nanoseconds.
> > > + * Gets an event from DRM and returns its timestamp in nanoseconds.
> > > + * Asserts if the event from DRM is not matched with requested one.
> > > + *
> > >   * This blocks until the event is received.
> > >   */
> > > -static uint64_t get_vblank_event_ns(data_t *data)
> > > +static uint64_t get_kernel_event_ns(data_t *data, uint32_t event)
> > >  {
> > >  	struct drm_event_vblank ev;
> > >
> > > -	igt_set_timeout(1, "Waiting for vblank event\n");
> > > +	igt_set_timeout(1, "Waiting for an event\n");
> > >  	igt_assert_eq(read(data->drm_fd, &ev, sizeof(ev)), sizeof(ev));
> > > +	igt_assert_eq(ev.base.type, event);
> > >  	igt_reset_timeout();
> > >
> > >  	return ev.tv_sec * NSECS_PER_SEC + ev.tv_usec * 1000ull;
> > > @@ -126,11 +130,11 @@ static range_t get_vrr_range(data_t *data,
> igt_output_t *output)
> > >  }
> > >
> > >  /* Returns a suitable vrr test frequency. */
> > > -static uint32_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > > +static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> > >  {
> > >  	drmModeModeInfo *mode = igt_output_get_mode(output);
> > >  	range_t range;
> > > -	uint32_t vtest;
> > > +	uint64_t vtest;
> > >
> > >  	/*
> > >  	 * The frequency with the fastest convergence speed should be
> > > @@ -165,7 +169,6 @@ static void set_vrr_on_pipe(data_t *data, enum
> pipe pipe, bool enabled)
> > >  static void prepare_test(data_t *data, igt_output_t *output, enum
> pipe pipe)
> > >  {
> > >  	drmModeModeInfo mode = *igt_output_get_mode(output);
> > > -	igt_plane_t *primary;
> > >  	cairo_t *cr;
> > >
> > >  	/* Reset output */
> > > @@ -189,8 +192,8 @@ static void prepare_test(data_t *data,
> igt_output_t *output, enum pipe pipe)
> > >  	igt_put_cairo_ctx(cr);
> > >
> > >  	/* Take care of any required modesetting before the test begins. */
> > > -	primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY);
> > > -	igt_plane_set_fb(primary, &data->fb0);
> > > +	data->primary = igt_output_get_plane_type(output,
> DRM_PLANE_TYPE_PRIMARY);
> > > +	igt_plane_set_fb(data->primary, &data->fb0);
> > >
> > >  	igt_display_commit_atomic(&data->display,
> > >  				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > > @@ -207,35 +210,28 @@ wait_for_vblank(data_t *data, enum pipe pipe)
> > >  	vbl.request.sequence = 1;
> > >  	drmWaitVBlank(data->drm_fd, &vbl);
> > >
> > > -	return get_vblank_event_ns(data);
> > > +	return get_kernel_event_ns(data, DRM_EVENT_VBLANK);
> > >  }
> > >
> > > -/* Performs an asynchronous non-blocking page-flip on a pipe. */
> > > -static int
> > > -do_flip(data_t *data, enum pipe pipe_id, igt_fb_t *fb)
> > > +/* Performs an atomic non-blocking page-flip on a pipe. */
> > > +static void
> > > +do_flip(data_t *data, igt_fb_t *fb)
> > >  {
> > > -	igt_pipe_t *pipe = &data->display.pipes[pipe_id];
> > >  	int ret;
> > >
> > >  	igt_set_timeout(1, "Scheduling page flip\n");
> > >
> > > -	/*
> > > -	 * Only the legacy flip ioctl supports async flips.
> > > -	 * It's also non-blocking, but returns -EBUSY if flipping too fast.
> > > -	 * 2x monitor tests will need async flips in the atomic API.
> > > -	 */
> > > +	igt_plane_set_fb(data->primary, fb);
> > > +
> > >  	do {
> > > -		ret = drmModePageFlip(data->drm_fd, pipe->crtc_id,
> > > -				      fb->fb_id,
> > > -				      DRM_MODE_PAGE_FLIP_EVENT |
> > > -				      DRM_MODE_PAGE_FLIP_ASYNC,
> > > -				      data);
> > > +		ret = igt_display_try_commit_atomic(&data->display,
> > > +				  DRM_MODE_ATOMIC_NONBLOCK |
> > > +				  DRM_MODE_PAGE_FLIP_EVENT,
> > > +				  data);
> 
> Why do we need to use igt_display_try_commit_atomic() and not just
> igt_display_commit_atomic()?
[Bhanu] As we are using DRM_MODE_ATOMIC_NONBLOCK flag, driver returns -EBUSY if flipping is too fast.
> 
> Also in set_vrr_on_pipe() function, I would prefer using
> igt_display_commit2() call.
[Bhanu] As we are using igt_require(display.is_atomic) in igt_fixture, I think it should be ok to use igt_display_commit_atomic().

> And IMO, the set_vrr_on_pipe() should be called before prepare_test()
> since the prop needs to be set before the modeset request.
> 
[Bhanu] Please consider below are the high level flow:

Prepare_test --> do modeset
    |
    |---->set_vrr_on_pipe --> 1
    |          |
    |          |---->Flip & measure --> expected result is > 75%  
    |
    |---->set_vrr_on_pipe --> 0
    |          |
    |          |---->Flip & measure --> expected result is < 10%
    V
Test cleanup --> do modeset

From above illustration, every time we change the vrr_enabled prop, do we need the full mode set?
If yes, then we need to do the modeset for i915 only, since AMD don't need modeset (Need to confirm)

> The other think that I had to change was reset vrr prop, then set it and
> then prepare_test
> so:
> 
> set_vrr_on_pipe(data, pipe, 0)
> set_vrr_on_pipe(data, pipe, 1)
> prepare_test()
> 
> This is needed since the driver doesnt do a full modeset if
> old_crtc_state.vrr_enabled == new_crtc_state.vrr_enabled
> 
> Manasi
> 
> > >  	} while (ret == -EBUSY);
> > >
> > >  	igt_assert_eq(ret, 0);
> > >  	igt_reset_timeout();
> > > -
> > > -	return 0;
> > >  }
> > >
> > >  /*
> > > @@ -246,11 +242,6 @@ do_flip(data_t *data, enum pipe pipe_id, igt_fb_t
> *fb)
> > >   * can arbitrarily restrict the bounds further than the absolute
> > >   * min and max range. But VRR is really about extending the flip
> > >   * to prevent stuttering or to match a source content rate.
> > > - *
> > > - * The only way to "present" at a fixed rate like userspace in a
> vendor
> > > - * neutral manner is to do it with async flips. This avoids the need
> > > - * to wait for next vblank and it should eventually converge at the
> > > - * desired rate.
> > >   */
> > >  static uint32_t
> > >  flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
> > > @@ -269,9 +260,14 @@ flip_and_measure(data_t *data, igt_output_t
> *output, enum pipe pipe,
> > >  		int64_t diff_ns;
> > >
> > >  		front = !front;
> > > -		do_flip(data, pipe, front ? &data->fb1 : &data->fb0);
> > > +		do_flip(data, front ? &data->fb1 : &data->fb0);
> > >
> > > -		vblank_ns = get_vblank_event_ns(data);
> > > +		/* We need to cpture flip event instead of vblank event,
> > 		            ^^capture
> >
> > > +		 * because vblank is triggered after each frame, but depending
> > > +		 * on the vblank evasion time flip might or might not happen in
> > > +		 * that same frame.
> > > +		 */
> > > +		vblank_ns = get_kernel_event_ns(data, DRM_EVENT_FLIP_COMPLETE);
> > Does it make sense to name this as event_ns, calling it vbalnk_ns makes
> it little
> > confusing since in the explanation, we said we are capture flip event
> here?
> >
> > Not a hard change requested, but just a suggestion.
> >
> > Regards
> > Manasi
> >
> > >  		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> > >  		last_vblank_ns = vblank_ns;
> > >
> > > @@ -359,6 +355,12 @@ test_basic(data_t *data, enum pipe pipe,
> igt_output_t *output, uint32_t flags)
> > >  		     "Target VRR off threshold exceeded, result was %u%%\n",
> > >  		     result);
> > >
> > > +	/* Clean-up */
> > > +	igt_plane_set_fb(data->primary, NULL);
> > > +	igt_output_set_pipe(output, PIPE_NONE);
> > > +	igt_display_commit_atomic(&data->display,
> > > +				  DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
> > > +
> > >  	igt_remove_fb(data->drm_fd, &data->fb1);
> > >  	igt_remove_fb(data->drm_fd, &data->fb0);
> > >  }
> > > --
> > > 2.20.1
> > >
> > _______________________________________________
> > igt-dev mailing list
> > igt-dev@lists.freedesktop.org
> > https://lists.freedesktop.org/mailman/listinfo/igt-dev
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] [PATCH v3 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[Bhanuprakash Modem]

Check flipline mode by making sure that flips happen at flipline
decision boundary.

Example: if monitor vrr range is 40 - 60Hz and

* flip at refresh_rate > 60Hz:
        Flip should happen at the flipline boundary & returned refresh rate
        would be 60Hz.
* flip at refresh_rate == 50Hz:
        Flip should happen right away so returned refresh rate is 50Hz.
* flip at refresh_rate < 40Hz:
        Flip should happen at the vmax so the returned refresh rate
        would be 40Hz.

Cc: Harry Wentland <harry.wentland@amd.com>
Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
Cc: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
---
 tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
 1 file changed, 76 insertions(+), 25 deletions(-)

diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
index 15db7695e8..2a11fe6afb 100644
--- a/tests/kms_vrr.c
+++ b/tests/kms_vrr.c
@@ -37,6 +37,7 @@ enum {
 	TEST_NONE = 0,
 	TEST_DPMS = 1 << 0,
 	TEST_SUSPEND = 1 << 1,
+	TEST_FLIPLINE = 1 << 2,
 };
 
 typedef struct range {
@@ -52,6 +53,12 @@ typedef struct data {
 	igt_fb_t fb1;
 } data_t;
 
+typedef struct vtest_ns {
+	uint64_t min;
+	uint64_t mid;
+	uint64_t max;
+} vtest_ns_t;
+
 typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
 
 /* Converts a timespec structure to nanoseconds. */
@@ -104,13 +111,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
 	return NSECS_PER_SEC / refresh;
 }
 
-/* Returns the min and max vrr range from the connector debugfs. */
+/* Read min and max vrr range from the connector debugfs.
+ *  - min range should be less than the current mode vfreq
+ *  - if max range is grater than the current mode vfreq, consider
+ *       current mode vfreq as the max range.
+ */
 static range_t get_vrr_range(data_t *data, igt_output_t *output)
 {
 	char buf[256];
 	char *start_loc;
 	int fd, res;
 	range_t range;
+	drmModeModeInfo *mode = igt_output_get_mode(output);
 
 	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
 	igt_assert(fd >= 0);
@@ -122,32 +134,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
 
 	igt_assert(start_loc = strstr(buf, "Min: "));
 	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
+	igt_require(mode->vrefresh > range.min);
 
 	igt_assert(start_loc = strstr(buf, "Max: "));
 	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
 
+	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
+
 	return range;
 }
 
-/* Returns a suitable vrr test frequency. */
-static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
+/* Returns vrr test frequency for min, mid & max range. */
+static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
 {
-	drmModeModeInfo *mode = igt_output_get_mode(output);
 	range_t range;
-	uint64_t vtest;
+	vtest_ns_t vtest_ns;
 
-	/*
-	 * The frequency with the fastest convergence speed should be
-	 * the midpoint between the current mode vfreq and the min
-	 * supported vfreq.
-	 */
 	range = get_vrr_range(data, output);
-	igt_require(mode->vrefresh > range.min);
+	vtest_ns.min = rate_from_refresh(range.min);
+	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
+	vtest_ns.max = rate_from_refresh(range.max);
 
-	vtest = (mode->vrefresh - range.min) / 2 + range.min;
-	igt_require(vtest < mode->vrefresh);
-
-	return rate_from_refresh(vtest);
+	return vtest_ns;
 }
 
 /* Returns true if an output supports VRR. */
@@ -250,6 +258,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 	uint64_t start_ns, last_vblank_ns;
 	uint32_t total_flip = 0, total_pass = 0;
 	bool front = false;
+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
 
 	/* Align with the vblank region to speed up convergence. */
 	last_vblank_ns = wait_for_vblank(data, pipe);
@@ -268,10 +277,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		 * that same frame.
 		 */
 		vblank_ns = get_kernel_event_ns(data, DRM_EVENT_FLIP_COMPLETE);
-		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
-		last_vblank_ns = vblank_ns;
-
-		total_flip += 1;
 
 		/*
 		 * Check if the difference between the two flip timestamps
@@ -281,9 +286,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 		 * difference between 144Hz and 143Hz which should give this
 		 * enough accuracy for most use cases.
 		 */
+		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
+			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
+		else if (rate_ns > vtest_ns.min)
+			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
+		else if (rate_ns < vtest_ns.max)
+			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
+
 		if (llabs(diff_ns) < 50000ll)
 			total_pass += 1;
 
+		last_vblank_ns = vblank_ns;
+		total_flip += 1;
+
 		now_ns = get_time_ns();
 		if (now_ns - start_ns > duration_ns)
 			break;
@@ -310,10 +325,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
 static void
 test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 {
-	uint64_t rate;
 	uint32_t result;
+	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
+	range_t range = get_vrr_range(data, output);
+	uint64_t rate = vtest_ns.mid;
 
-	rate = get_test_rate_ns(data, output);
+	igt_info("VRR Test execution on %s, PIPE_%s\n",
+		 output->name, kmstest_pipe_name(pipe));
 
 	prepare_test(data, output, pipe);
 
@@ -339,6 +357,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
 					      SUSPEND_TEST_NONE);
 
+	/*
+	 * Check flipline mode by making sure that flips happen at flipline
+	 * decision boundary.
+	 *
+	 * Example: if range is 40 - 60Hz and
+	 * if refresh_rate > 60Hz:
+	 *      Flip should happen at the flipline boundary & returned refresh rate
+	 *      would be 60Hz.
+	 * if refresh_rate is 50Hz:
+	 *      Flip will happen right away so returned refresh rate is 50Hz.
+	 * if refresh_rate < 40Hz:
+	 *      Flip should happen at the vmax so the returned refresh rate
+	 *      would be 40Hz.
+	 */
+	if (flags & TEST_FLIPLINE) {
+		rate = rate_from_refresh(range.min - 5);
+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
+		igt_assert_f(result > 75,
+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+			     rate, result);
+
+		rate = rate_from_refresh(range.max + 5);
+		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
+		igt_assert_f(result > 75,
+			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+			     rate, result);
+	}
+
+	rate = vtest_ns.mid;
 	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
 
 	set_vrr_on_pipe(data, pipe, 0);
@@ -346,14 +393,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
 	/* This check is delayed until after VRR is disabled so it isn't
 	 * left enabled if the test fails. */
 	igt_assert_f(result > 75,
-		     "Target VRR on threshold not reached, result was %u%%\n",
-		     result);
+		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
+		     rate, result);
 
 	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
 
 	igt_assert_f(result < 10,
-		     "Target VRR off threshold exceeded, result was %u%%\n",
-		     result);
+		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
+		     rate, result);
 
 	/* Clean-up */
 	igt_plane_set_fb(data->primary, NULL);
@@ -413,6 +460,10 @@ igt_main
 	igt_subtest("flip-suspend")
 		run_vrr_test(&data, test_basic, TEST_SUSPEND);
 
+	igt_describe("Make sure that flips happen at flipline decision boundary.");
+	igt_subtest("flipline")
+		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
+
 	igt_fixture {
 		igt_display_fini(&data.display);
 	}
-- 
2.20.1

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

Re: [igt-dev] [PATCH v3 2/2] tests/kms_vrr: Add new subtest to validate Flipline mode

[Kazlauskas, Nicholas]

On 2020-08-20 12:42 p.m., Bhanuprakash Modem wrote:
> Check flipline mode by making sure that flips happen at flipline
> decision boundary.
> 
> Example: if monitor vrr range is 40 - 60Hz and
> 
> * flip at refresh_rate > 60Hz:
>          Flip should happen at the flipline boundary & returned refresh rate
>          would be 60Hz.
> * flip at refresh_rate == 50Hz:
>          Flip should happen right away so returned refresh rate is 50Hz.
> * flip at refresh_rate < 40Hz:
>          Flip should happen at the vmax so the returned refresh rate
>          would be 40Hz.

Apologies for the delay for getting around to looking at this.

The first two patches in this series LGTM and pass on our hardware, so 
with Manasi's comments addressed those two are:

Reviewed-by: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>

However, I do have some comments about this last patch. On AMDGPU the 
behavior for rates below the range differs.

If refresh_rate < 40Hz on a 40 - 60Hz display we will use vmax, 60Hz. 
IIRC this produces a result with noticeably less stuttering.

For refresh_rate < 40Hz on a display that has vmin < 2 * vmax we'll pick 
a multiple of refresh_rate within vmin to vmax.

The behavior is left to the driver from the DRM API so the approach 
suggested along with the one currently in our driver is allowed:

"
The minimum vertical front porch duration is defined as the vertical 
front porch duration for the current mode.

The maximum vertical front porch duration is greater than or equal to 
the minimum vertical front porch duration. The duration is derived from 
the minimum supported variable refresh rate for the connector.

The driver may place further restrictions within these minimum and 
maximum bounds.
"

Regards,
Nicholas Kazlauskas

> 
> Cc: Harry Wentland <harry.wentland@amd.com>
> Cc: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com>
> Cc: Manasi Navare <manasi.d.navare@intel.com>
> Signed-off-by: Bhanuprakash Modem <bhanuprakash.modem@intel.com>
> ---
>   tests/kms_vrr.c | 101 ++++++++++++++++++++++++++++++++++++------------
>   1 file changed, 76 insertions(+), 25 deletions(-)
> 
> diff --git a/tests/kms_vrr.c b/tests/kms_vrr.c
> index 15db7695e8..2a11fe6afb 100644
> --- a/tests/kms_vrr.c
> +++ b/tests/kms_vrr.c
> @@ -37,6 +37,7 @@ enum {
>   	TEST_NONE = 0,
>   	TEST_DPMS = 1 << 0,
>   	TEST_SUSPEND = 1 << 1,
> +	TEST_FLIPLINE = 1 << 2,
>   };
>   
>   typedef struct range {
> @@ -52,6 +53,12 @@ typedef struct data {
>   	igt_fb_t fb1;
>   } data_t;
>   
> +typedef struct vtest_ns {
> +	uint64_t min;
> +	uint64_t mid;
> +	uint64_t max;
> +} vtest_ns_t;
> +
>   typedef void (*test_t)(data_t*, enum pipe, igt_output_t*, uint32_t);
>   
>   /* Converts a timespec structure to nanoseconds. */
> @@ -104,13 +111,18 @@ static uint64_t rate_from_refresh(uint64_t refresh)
>   	return NSECS_PER_SEC / refresh;
>   }
>   
> -/* Returns the min and max vrr range from the connector debugfs. */
> +/* Read min and max vrr range from the connector debugfs.
> + *  - min range should be less than the current mode vfreq
> + *  - if max range is grater than the current mode vfreq, consider
> + *       current mode vfreq as the max range.
> + */
>   static range_t get_vrr_range(data_t *data, igt_output_t *output)
>   {
>   	char buf[256];
>   	char *start_loc;
>   	int fd, res;
>   	range_t range;
> +	drmModeModeInfo *mode = igt_output_get_mode(output);
>   
>   	fd = igt_debugfs_connector_dir(data->drm_fd, output->name, O_RDONLY);
>   	igt_assert(fd >= 0);
> @@ -122,32 +134,28 @@ static range_t get_vrr_range(data_t *data, igt_output_t *output)
>   
>   	igt_assert(start_loc = strstr(buf, "Min: "));
>   	igt_assert_eq(sscanf(start_loc, "Min: %u", &range.min), 1);
> +	igt_require(mode->vrefresh > range.min);
>   
>   	igt_assert(start_loc = strstr(buf, "Max: "));
>   	igt_assert_eq(sscanf(start_loc, "Max: %u", &range.max), 1);
>   
> +	range.max = (mode->vrefresh < range.max) ? mode->vrefresh : range.max;
> +
>   	return range;
>   }
>   
> -/* Returns a suitable vrr test frequency. */
> -static uint64_t get_test_rate_ns(data_t *data, igt_output_t *output)
> +/* Returns vrr test frequency for min, mid & max range. */
> +static vtest_ns_t get_test_rate_ns(data_t *data, igt_output_t *output)
>   {
> -	drmModeModeInfo *mode = igt_output_get_mode(output);
>   	range_t range;
> -	uint64_t vtest;
> +	vtest_ns_t vtest_ns;
>   
> -	/*
> -	 * The frequency with the fastest convergence speed should be
> -	 * the midpoint between the current mode vfreq and the min
> -	 * supported vfreq.
> -	 */
>   	range = get_vrr_range(data, output);
> -	igt_require(mode->vrefresh > range.min);
> +	vtest_ns.min = rate_from_refresh(range.min);
> +	vtest_ns.mid = rate_from_refresh(((range.max + range.min) / 2));
> +	vtest_ns.max = rate_from_refresh(range.max);
>   
> -	vtest = (mode->vrefresh - range.min) / 2 + range.min;
> -	igt_require(vtest < mode->vrefresh);
> -
> -	return rate_from_refresh(vtest);
> +	return vtest_ns;
>   }
>   
>   /* Returns true if an output supports VRR. */
> @@ -250,6 +258,7 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>   	uint64_t start_ns, last_vblank_ns;
>   	uint32_t total_flip = 0, total_pass = 0;
>   	bool front = false;
> +	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
>   
>   	/* Align with the vblank region to speed up convergence. */
>   	last_vblank_ns = wait_for_vblank(data, pipe);
> @@ -268,10 +277,6 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>   		 * that same frame.
>   		 */
>   		vblank_ns = get_kernel_event_ns(data, DRM_EVENT_FLIP_COMPLETE);
> -		diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> -		last_vblank_ns = vblank_ns;
> -
> -		total_flip += 1;
>   
>   		/*
>   		 * Check if the difference between the two flip timestamps
> @@ -281,9 +286,19 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>   		 * difference between 144Hz and 143Hz which should give this
>   		 * enough accuracy for most use cases.
>   		 */
> +		if ((rate_ns <= vtest_ns.min) && (rate_ns >= vtest_ns.max))
> +			diff_ns = rate_ns - (vblank_ns - last_vblank_ns);
> +		else if (rate_ns > vtest_ns.min)
> +			diff_ns = vtest_ns.min - (vblank_ns - last_vblank_ns);
> +		else if (rate_ns < vtest_ns.max)
> +			diff_ns = vtest_ns.max - (vblank_ns - last_vblank_ns);
> +
>   		if (llabs(diff_ns) < 50000ll)
>   			total_pass += 1;
>   
> +		last_vblank_ns = vblank_ns;
> +		total_flip += 1;
> +
>   		now_ns = get_time_ns();
>   		if (now_ns - start_ns > duration_ns)
>   			break;
> @@ -310,10 +325,13 @@ flip_and_measure(data_t *data, igt_output_t *output, enum pipe pipe,
>   static void
>   test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>   {
> -	uint64_t rate;
>   	uint32_t result;
> +	vtest_ns_t vtest_ns = get_test_rate_ns(data, output);
> +	range_t range = get_vrr_range(data, output);
> +	uint64_t rate = vtest_ns.mid;
>   
> -	rate = get_test_rate_ns(data, output);
> +	igt_info("VRR Test execution on %s, PIPE_%s\n",
> +		 output->name, kmstest_pipe_name(pipe));
>   
>   	prepare_test(data, output, pipe);
>   
> @@ -339,6 +357,35 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>   		igt_system_suspend_autoresume(SUSPEND_STATE_MEM,
>   					      SUSPEND_TEST_NONE);
>   
> +	/*
> +	 * Check flipline mode by making sure that flips happen at flipline
> +	 * decision boundary.
> +	 *
> +	 * Example: if range is 40 - 60Hz and
> +	 * if refresh_rate > 60Hz:
> +	 *      Flip should happen at the flipline boundary & returned refresh rate
> +	 *      would be 60Hz.
> +	 * if refresh_rate is 50Hz:
> +	 *      Flip will happen right away so returned refresh rate is 50Hz.
> +	 * if refresh_rate < 40Hz:
> +	 *      Flip should happen at the vmax so the returned refresh rate
> +	 *      would be 40Hz.
> +	 */
> +	if (flags & TEST_FLIPLINE) {
> +		rate = rate_from_refresh(range.min - 5);
> +		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> +		igt_assert_f(result > 75,
> +			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> +			     rate, result);
> +
> +		rate = rate_from_refresh(range.max + 5);
> +		result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
> +		igt_assert_f(result > 75,
> +			     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> +			     rate, result);
> +	}
> +
> +	rate = vtest_ns.mid;
>   	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>   
>   	set_vrr_on_pipe(data, pipe, 0);
> @@ -346,14 +393,14 @@ test_basic(data_t *data, enum pipe pipe, igt_output_t *output, uint32_t flags)
>   	/* This check is delayed until after VRR is disabled so it isn't
>   	 * left enabled if the test fails. */
>   	igt_assert_f(result > 75,
> -		     "Target VRR on threshold not reached, result was %u%%\n",
> -		     result);
> +		     "Refresh rate %"PRIu64"ns: Target VRR on threshold not reached, result was %u%%\n",
> +		     rate, result);
>   
>   	result = flip_and_measure(data, output, pipe, rate, TEST_DURATION_NS);
>   
>   	igt_assert_f(result < 10,
> -		     "Target VRR off threshold exceeded, result was %u%%\n",
> -		     result);
> +		     "Refresh rate %"PRIu64"ns: Target VRR off threshold exceeded, result was %u%%\n",
> +		     rate, result);
>   
>   	/* Clean-up */
>   	igt_plane_set_fb(data->primary, NULL);
> @@ -413,6 +460,10 @@ igt_main
>   	igt_subtest("flip-suspend")
>   		run_vrr_test(&data, test_basic, TEST_SUSPEND);
>   
> +	igt_describe("Make sure that flips happen at flipline decision boundary.");
> +	igt_subtest("flipline")
> +		run_vrr_test(&data, test_basic, TEST_FLIPLINE);
> +
>   	igt_fixture {
>   		igt_display_fini(&data.display);
>   	}
> 

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

[igt-dev] ✗ Fi.CI.IGT: failure for New subtest for VRR Flipline mode (rev4)

[Patchwork]

[-- Attachment #1.1: Type: text/plain, Size: 21248 bytes --]

== Series Details ==

Series: New subtest for VRR Flipline mode (rev4)
URL   : https://patchwork.freedesktop.org/series/77128/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_8909_full -> IGTPW_4896_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_4896_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_4896_full, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/index.html

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in IGTPW_4896_full:

### IGT changes ###

#### Possible regressions ####

  * igt@kms_cursor_legacy@cursor-vs-flip-varying-size:
    - shard-hsw:          [PASS][1] -> [FAIL][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw8/igt@kms_cursor_legacy@cursor-vs-flip-varying-size.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw1/igt@kms_cursor_legacy@cursor-vs-flip-varying-size.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-indfb-plflip-blt:
    - shard-tglb:         [PASS][3] -> [FAIL][4]
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-tglb8/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-indfb-plflip-blt.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-tglb8/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-indfb-plflip-blt.html

  * {igt@kms_vrr@flipline} (NEW):
    - shard-tglb:         NOTRUN -> [SKIP][5]
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-tglb8/igt@kms_vrr@flipline.html
    - shard-iclb:         NOTRUN -> [SKIP][6]
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb1/igt@kms_vrr@flipline.html

  
New tests
---------

  New tests have been introduced between CI_DRM_8909_full and IGTPW_4896_full:

### New IGT tests (1) ###

  * igt@kms_vrr@flipline:
    - Statuses : 7 skip(s)
    - Exec time: [0.0] s

  

Known issues
------------

  Here are the changes found in IGTPW_4896_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_exec_endless@dispatch@vcs1:
    - shard-tglb:         [PASS][7] -> [INCOMPLETE][8] ([i915#1958])
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-tglb1/igt@gem_exec_endless@dispatch@vcs1.html
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-tglb8/igt@gem_exec_endless@dispatch@vcs1.html

  * igt@gem_exec_nop@basic-parallel:
    - shard-snb:          [PASS][9] -> [TIMEOUT][10] ([i915#1958]) +1 similar issue
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-snb4/igt@gem_exec_nop@basic-parallel.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-snb5/igt@gem_exec_nop@basic-parallel.html

  * igt@gem_exec_whisper@basic-queues-forked-all:
    - shard-glk:          [PASS][11] -> [DMESG-WARN][12] ([i915#118] / [i915#95])
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk3/igt@gem_exec_whisper@basic-queues-forked-all.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk9/igt@gem_exec_whisper@basic-queues-forked-all.html

  * igt@gem_mmap_gtt@cpuset-medium-copy:
    - shard-iclb:         [PASS][13] -> [DMESG-WARN][14] ([i915#1982])
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb3/igt@gem_mmap_gtt@cpuset-medium-copy.html
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb2/igt@gem_mmap_gtt@cpuset-medium-copy.html

  * igt@i915_pm_dc@dc6-psr:
    - shard-iclb:         [PASS][15] -> [FAIL][16] ([i915#1899])
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb3/igt@i915_pm_dc@dc6-psr.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb5/igt@i915_pm_dc@dc6-psr.html

  * igt@i915_pm_rc6_residency@rc6-fence:
    - shard-iclb:         [PASS][17] -> [WARN][18] ([i915#1515])
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb7/igt@i915_pm_rc6_residency@rc6-fence.html
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb7/igt@i915_pm_rc6_residency@rc6-fence.html

  * igt@i915_query@query-topology-coherent-slice-mask:
    - shard-hsw:          [PASS][19] -> [TIMEOUT][20] ([i915#1958]) +2 similar issues
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw8/igt@i915_query@query-topology-coherent-slice-mask.html
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw2/igt@i915_query@query-topology-coherent-slice-mask.html

  * igt@kms_big_fb@x-tiled-64bpp-rotate-180:
    - shard-glk:          [PASS][21] -> [DMESG-FAIL][22] ([i915#118] / [i915#95])
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk3/igt@kms_big_fb@x-tiled-64bpp-rotate-180.html
   [22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk8/igt@kms_big_fb@x-tiled-64bpp-rotate-180.html

  * igt@kms_big_fb@x-tiled-8bpp-rotate-0:
    - shard-apl:          [PASS][23] -> [DMESG-WARN][24] ([i915#1635] / [i915#1982])
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-apl7/igt@kms_big_fb@x-tiled-8bpp-rotate-0.html
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-apl2/igt@kms_big_fb@x-tiled-8bpp-rotate-0.html

  * igt@kms_color@pipe-c-degamma:
    - shard-apl:          [PASS][25] -> [FAIL][26] ([i915#1635] / [i915#71])
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-apl6/igt@kms_color@pipe-c-degamma.html
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-apl8/igt@kms_color@pipe-c-degamma.html
    - shard-glk:          [PASS][27] -> [FAIL][28] ([i915#71])
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk9/igt@kms_color@pipe-c-degamma.html
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk7/igt@kms_color@pipe-c-degamma.html
    - shard-kbl:          [PASS][29] -> [FAIL][30] ([i915#71])
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl1/igt@kms_color@pipe-c-degamma.html
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl4/igt@kms_color@pipe-c-degamma.html

  * igt@kms_cursor_crc@pipe-b-cursor-64x21-random:
    - shard-glk:          [PASS][31] -> [FAIL][32] ([i915#54])
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk1/igt@kms_cursor_crc@pipe-b-cursor-64x21-random.html
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk3/igt@kms_cursor_crc@pipe-b-cursor-64x21-random.html
    - shard-apl:          [PASS][33] -> [FAIL][34] ([i915#1635] / [i915#54])
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-apl6/igt@kms_cursor_crc@pipe-b-cursor-64x21-random.html
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-apl8/igt@kms_cursor_crc@pipe-b-cursor-64x21-random.html
    - shard-kbl:          [PASS][35] -> [FAIL][36] ([i915#54])
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl2/igt@kms_cursor_crc@pipe-b-cursor-64x21-random.html
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl7/igt@kms_cursor_crc@pipe-b-cursor-64x21-random.html

  * igt@kms_cursor_legacy@short-flip-after-cursor-atomic-transitions:
    - shard-kbl:          [PASS][37] -> [DMESG-WARN][38] ([i915#1982]) +4 similar issues
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl7/igt@kms_cursor_legacy@short-flip-after-cursor-atomic-transitions.html
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl7/igt@kms_cursor_legacy@short-flip-after-cursor-atomic-transitions.html

  * igt@kms_flip@flip-vs-expired-vblank@b-dp1:
    - shard-apl:          [PASS][39] -> [FAIL][40] ([i915#1635] / [i915#79])
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-apl4/igt@kms_flip@flip-vs-expired-vblank@b-dp1.html
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-apl6/igt@kms_flip@flip-vs-expired-vblank@b-dp1.html

  * igt@kms_flip@flip-vs-suspend-interruptible@a-dp1:
    - shard-kbl:          [PASS][41] -> [DMESG-WARN][42] ([i915#180]) +10 similar issues
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl2/igt@kms_flip@flip-vs-suspend-interruptible@a-dp1.html
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl4/igt@kms_flip@flip-vs-suspend-interruptible@a-dp1.html

  * igt@kms_flip@flip-vs-suspend-interruptible@c-hdmi-a1:
    - shard-hsw:          [PASS][43] -> [INCOMPLETE][44] ([i915#2055])
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw1/igt@kms_flip@flip-vs-suspend-interruptible@c-hdmi-a1.html
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw1/igt@kms_flip@flip-vs-suspend-interruptible@c-hdmi-a1.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-onoff:
    - shard-tglb:         [PASS][45] -> [DMESG-WARN][46] ([i915#1982]) +2 similar issues
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-tglb2/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-onoff.html
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-tglb8/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbc-badstride:
    - shard-glk:          [PASS][47] -> [DMESG-WARN][48] ([i915#1982])
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk6/igt@kms_frontbuffer_tracking@fbc-badstride.html
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk3/igt@kms_frontbuffer_tracking@fbc-badstride.html

  * igt@kms_psr2_su@page_flip:
    - shard-iclb:         [PASS][49] -> [SKIP][50] ([fdo#109642] / [fdo#111068])
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb2/igt@kms_psr2_su@page_flip.html
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb6/igt@kms_psr2_su@page_flip.html

  * igt@kms_psr@psr2_sprite_plane_move:
    - shard-iclb:         [PASS][51] -> [SKIP][52] ([fdo#109441]) +3 similar issues
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb2/igt@kms_psr@psr2_sprite_plane_move.html
   [52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb4/igt@kms_psr@psr2_sprite_plane_move.html

  * igt@perf@blocking-parameterized:
    - shard-iclb:         [PASS][53] -> [FAIL][54] ([i915#1542])
   [53]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb6/igt@perf@blocking-parameterized.html
   [54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb8/igt@perf@blocking-parameterized.html

  * igt@prime_busy@before@vecs0:
    - shard-hsw:          [PASS][55] -> [FAIL][56] ([i915#2258]) +1 similar issue
   [55]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw2/igt@prime_busy@before@vecs0.html
   [56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw8/igt@prime_busy@before@vecs0.html

  
#### Possible fixes ####

  * igt@gem_ctx_persistence@processes:
    - shard-tglb:         [FAIL][57] ([i915#2376]) -> [PASS][58]
   [57]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-tglb1/igt@gem_ctx_persistence@processes.html
   [58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-tglb5/igt@gem_ctx_persistence@processes.html

  * igt@gem_ctx_shared@q-smoketest-all:
    - shard-glk:          [DMESG-WARN][59] ([i915#118] / [i915#95]) -> [PASS][60]
   [59]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk4/igt@gem_ctx_shared@q-smoketest-all.html
   [60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk7/igt@gem_ctx_shared@q-smoketest-all.html

  * igt@gem_exec_suspend@basic-s3:
    - shard-snb:          [TIMEOUT][61] ([i915#1958]) -> [PASS][62] +2 similar issues
   [61]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-snb4/igt@gem_exec_suspend@basic-s3.html
   [62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-snb4/igt@gem_exec_suspend@basic-s3.html

  * igt@gen9_exec_parse@allowed-all:
    - shard-apl:          [DMESG-WARN][63] ([i915#1436] / [i915#1635] / [i915#716]) -> [PASS][64]
   [63]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-apl8/igt@gen9_exec_parse@allowed-all.html
   [64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-apl8/igt@gen9_exec_parse@allowed-all.html

  * igt@kms_cursor_legacy@2x-long-cursor-vs-flip-legacy:
    - shard-hsw:          [FAIL][65] ([i915#96]) -> [PASS][66]
   [65]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw8/igt@kms_cursor_legacy@2x-long-cursor-vs-flip-legacy.html
   [66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw1/igt@kms_cursor_legacy@2x-long-cursor-vs-flip-legacy.html

  * igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size:
    - shard-tglb:         [DMESG-WARN][67] ([i915#1982]) -> [PASS][68] +4 similar issues
   [67]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-tglb5/igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size.html
   [68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-tglb1/igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size.html

  * igt@kms_flip@2x-plain-flip-ts-check-interruptible@bc-hdmi-a1-hdmi-a2:
    - shard-glk:          [FAIL][69] ([i915#2122]) -> [PASS][70]
   [69]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk7/igt@kms_flip@2x-plain-flip-ts-check-interruptible@bc-hdmi-a1-hdmi-a2.html
   [70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk9/igt@kms_flip@2x-plain-flip-ts-check-interruptible@bc-hdmi-a1-hdmi-a2.html

  * igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-shrfb-draw-blt:
    - shard-kbl:          [DMESG-WARN][71] ([i915#1982]) -> [PASS][72] +1 similar issue
   [71]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl1/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-shrfb-draw-blt.html
   [72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl4/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-shrfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbc-suspend:
    - shard-kbl:          [INCOMPLETE][73] ([i915#155]) -> [PASS][74]
   [73]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl2/igt@kms_frontbuffer_tracking@fbc-suspend.html
   [74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl1/igt@kms_frontbuffer_tracking@fbc-suspend.html

  * igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a:
    - shard-kbl:          [DMESG-WARN][75] ([i915#180]) -> [PASS][76] +5 similar issues
   [75]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-kbl4/igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a.html
   [76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-kbl4/igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a.html

  * igt@kms_plane_cursor@pipe-a-primary-size-128:
    - shard-glk:          [DMESG-WARN][77] ([i915#1982]) -> [PASS][78]
   [77]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-glk9/igt@kms_plane_cursor@pipe-a-primary-size-128.html
   [78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-glk2/igt@kms_plane_cursor@pipe-a-primary-size-128.html

  * igt@kms_psr@psr2_cursor_render:
    - shard-iclb:         [SKIP][79] ([fdo#109441]) -> [PASS][80] +2 similar issues
   [79]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb4/igt@kms_psr@psr2_cursor_render.html
   [80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb2/igt@kms_psr@psr2_cursor_render.html

  * igt@kms_vblank@pipe-a-wait-forked-busy-hang:
    - shard-snb:          [SKIP][81] ([fdo#109271]) -> [PASS][82] +1 similar issue
   [81]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-snb4/igt@kms_vblank@pipe-a-wait-forked-busy-hang.html
   [82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-snb2/igt@kms_vblank@pipe-a-wait-forked-busy-hang.html

  * igt@perf@oa-exponents:
    - shard-hsw:          [INCOMPLETE][83] ([i915#1958]) -> [PASS][84]
   [83]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw7/igt@perf@oa-exponents.html
   [84]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw1/igt@perf@oa-exponents.html

  * igt@perf_pmu@module-unload:
    - shard-iclb:         [DMESG-WARN][85] ([i915#1982]) -> [PASS][86]
   [85]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-iclb5/igt@perf_pmu@module-unload.html
   [86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-iclb8/igt@perf_pmu@module-unload.html

  * igt@prime_busy@hang-wait@bcs0:
    - shard-hsw:          [FAIL][87] ([i915#2258]) -> [PASS][88] +5 similar issues
   [87]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw8/igt@prime_busy@hang-wait@bcs0.html
   [88]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw8/igt@prime_busy@hang-wait@bcs0.html

  
#### Warnings ####

  * igt@gem_exec_schedule@preemptive-hang:
    - shard-snb:          [TIMEOUT][89] ([i915#1958]) -> [SKIP][90] ([fdo#109271]) +1 similar issue
   [89]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-snb4/igt@gem_exec_schedule@preemptive-hang.html
   [90]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-snb2/igt@gem_exec_schedule@preemptive-hang.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-cpu:
    - shard-hsw:          [SKIP][91] ([fdo#109271]) -> [TIMEOUT][92] ([i915#1958]) +1 similar issue
   [91]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw4/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-cpu.html
   [92]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw2/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-cpu.html

  * igt@kms_pipe_b_c_ivb@pipe-b-double-modeset-then-modeset-pipe-c:
    - shard-snb:          [SKIP][93] ([fdo#109271]) -> [TIMEOUT][94] ([i915#1958]) +2 similar issues
   [93]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-snb4/igt@kms_pipe_b_c_ivb@pipe-b-double-modeset-then-modeset-pipe-c.html
   [94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-snb5/igt@kms_pipe_b_c_ivb@pipe-b-double-modeset-then-modeset-pipe-c.html

  * igt@runner@aborted:
    - shard-hsw:          ([FAIL][95], [FAIL][96]) ([i915#1958] / [i915#2283]) -> [FAIL][97] ([i915#2283])
   [95]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw7/igt@runner@aborted.html
   [96]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8909/shard-hsw8/igt@runner@aborted.html
   [97]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/shard-hsw1/igt@runner@aborted.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [fdo#109441]: https://bugs.freedesktop.org/show_bug.cgi?id=109441
  [fdo#109642]: https://bugs.freedesktop.org/show_bug.cgi?id=109642
  [fdo#111068]: https://bugs.freedesktop.org/show_bug.cgi?id=111068
  [i915#118]: https://gitlab.freedesktop.org/drm/intel/issues/118
  [i915#1436]: https://gitlab.freedesktop.org/drm/intel/issues/1436
  [i915#1515]: https://gitlab.freedesktop.org/drm/intel/issues/1515
  [i915#1542]: https://gitlab.freedesktop.org/drm/intel/issues/1542
  [i915#155]: https://gitlab.freedesktop.org/drm/intel/issues/155
  [i915#1635]: https://gitlab.freedesktop.org/drm/intel/issues/1635
  [i915#180]: https://gitlab.freedesktop.org/drm/intel/issues/180
  [i915#1899]: https://gitlab.freedesktop.org/drm/intel/issues/1899
  [i915#1958]: https://gitlab.freedesktop.org/drm/intel/issues/1958
  [i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
  [i915#2055]: https://gitlab.freedesktop.org/drm/intel/issues/2055
  [i915#2122]: https://gitlab.freedesktop.org/drm/intel/issues/2122
  [i915#2258]: https://gitlab.freedesktop.org/drm/intel/issues/2258
  [i915#2283]: https://gitlab.freedesktop.org/drm/intel/issues/2283
  [i915#2376]: https://gitlab.freedesktop.org/drm/intel/issues/2376
  [i915#54]: https://gitlab.freedesktop.org/drm/intel/issues/54
  [i915#71]: https://gitlab.freedesktop.org/drm/intel/issues/71
  [i915#716]: https://gitlab.freedesktop.org/drm/intel/issues/716
  [i915#79]: https://gitlab.freedesktop.org/drm/intel/issues/79
  [i915#95]: https://gitlab.freedesktop.org/drm/intel/issues/95
  [i915#96]: https://gitlab.freedesktop.org/drm/intel/issues/96


Participating hosts (11 -> 8)
------------------------------

  Missing    (3): pig-skl-6260u pig-glk-j5005 pig-icl-1065g7 


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_5769 -> IGTPW_4896
  * Piglit: piglit_4509 -> None

  CI-20190529: 20190529
  CI_DRM_8909: 1939e049a8ec6cef03a098f7cc99cb0bbcff21c6 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_4896: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/index.html
  IGT_5769: 4e5f76be680b65780204668e302026cf638decc9 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
  piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4896/index.html

[-- Attachment #1.2: Type: text/html, Size: 25430 bytes --]

[-- Attachment #2: Type: text/plain, Size: 154 bytes --]

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