Skip to contentSkip to conversation

Convert PSR2 sf & su test to dynamic

PATCH Superseded Jeevan B 4 participants 11 messages Sep 8, 2022 – Sep 14, 2022

v1 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Jeevan B

author
#0 lore raw

cover Convert PSR2 sf & su test to dynamic

Convert psr2_sf & psr2_su patch to dynamic subtests.
We check psr2 support for each pipe and if the pipe supports then its added as part of dynamic subtest instead to running through all pipe.

Jeevan B (2):
tests/i915/kms_psr2_su: Convert tests to dynamic tests/i915/kms_psr2_sf: Convert tests to dynamic

 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++------------
 tests/i915/kms_psr2_su.c |  63 ++++++----
 2 files changed, 221 insertions(+), 101 deletions(-)
Signature · 1 line
2.36.0
author
#1 lore raw

PATCH 1/2 tests/i915/kms_psr2_su: Convert tests to dynamic

Converting the existing subtests to dynamic subtests. Adding support for each_pipe, currently PSR2 is supported on PIPE_A so breaking the loop for other pipes currently.

v2: Add commit message and change break to continue. (Jouni)
v3: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_su.c | 63 +++++++++++++++++++++++++---------------
 1 file changed, 40 insertions(+), 23 deletions(-)
tests/i915/kms_psr2_su.c +40 -23
index caccf713..f63f1483 100644
@@ -260,13 +260,30 @@ static void cleanup(data_t *data)
 	igt_remove_fb(data->drm_fd, &data->fb[0]);
 }
 
+static int check_psr2_support(data_t *data, enum pipe pipe, int x)
+{
+	igt_output_t *output;
+	igt_display_t *display = &data->display;
+
+	igt_display_reset(display);
+	output = data->output;
+	igt_output_set_pipe(output, pipe);
+
+	prepare(data);
+	x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2);
+	cleanup(data);
+
+	return x;
+}
+
 igt_main
 {
 	data_t data = {};
+	enum pipe pipe;
+	int r;
 
 	igt_fixture {
 		struct itimerspec interval;
-		int r;
 
 		data.drm_fd = drm_open_driver_master(DRIVER_INTEL);
 		data.debugfs_fd = igt_debugfs_dir(data.drm_fd);
@@ -287,12 +304,6 @@ igt_main
 			      "Error enabling PSR2\n");
 		data.op = FRONTBUFFER;
 		data.format = DRM_FORMAT_XRGB8888;
-		prepare(&data);
-		r = psr_wait_entry(data.debugfs_fd, PSR_MODE_2);
-		cleanup(&data);
-		if (!r)
-			psr_print_debugfs(data.debugfs_fd);
-		igt_require_f(r, "PSR2 can not be enabled\n");
 
 		/* blocking timerfd */
 		data.change_screen_timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
@@ -312,23 +323,29 @@ igt_main
 		while (*format != DRM_FORMAT_INVALID) {
 			data.format = *format++;
 			igt_describe("Test that selective update works when screen changes");
-			igt_subtest_f("%s-%s", op_str(data.op), igt_format_str(data.format)) {
-				if (data.op == FRONTBUFFER &&
-				    intel_display_ver(intel_get_drm_devid(data.drm_fd)) >= 12) {
-					/*
-					 * FIXME: Display 12+ platforms now have PSR2
-					 * selective fetch enabled by default but we
-					 * still can't properly handle frontbuffer
-					 * rendering, so right it does full frame
-					 * fetches at every frontbuffer rendering.
-					 * So it is expected that this test will fail
-					 * in display 12+ platform for now.
-					 */
-					igt_skip("PSR2 selective fetch is doing full frame fetches for frontbuffer rendering\n");
+			igt_subtest_with_dynamic_f("%s-%s", op_str(data.op), igt_format_str(data.format)) {
+				for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+					if (check_psr2_support(&data, pipe, r)) {
+						igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+							if (data.op == FRONTBUFFER &&
+							    intel_display_ver(intel_get_drm_devid(data.drm_fd)) >= 12) {
+								/*
+								 * FIXME: Display 12+ platforms now have PSR2
+								 * selective fetch enabled by default but we
+								 * still can't properly handle frontbuffer
+								 * rendering, so right it does full frame
+								 * fetches at every frontbuffer rendering.
+								 * So it is expected that this test will fail
+								 * in display 12+ platform for now.
+								 */
+								igt_skip("PSR2 selective fetch is doing full frame fetches for frontbuffer rendering\n");
+							}
+							prepare(&data);
+							run(&data);
+							cleanup(&data);
+						}
+					}
 				}
-				prepare(&data);
-				run(&data);
-				cleanup(&data);
 			}
 		}
 	}
Signature · 1 line
2.36.0
#2 lore raw

Re: [igt-dev] [PATCH i-g-t 1/2] tests/i915/kms_psr2_su: Convert tests to dynamic

Quoted 22 lines · Jeevan B

Converting the existing subtests to dynamic subtests. Adding support for each_pipe, currently PSR2 is supported on PIPE_A so breaking the loop for other pipes currently.

v2: Add commit message and change break to continue. (Jouni)
v3: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_su.c | 63 +++++++++++++++++++++++++------------- --

 1 file changed, 40 insertions(+), 23 deletions(-)
tests/i915/kms_psr2_su.c +0 -0
index caccf713..f63f1483 100644
@@ -260,13 +260,30 @@ static void cleanup(data_t *data)
         igt_remove_fb(data->drm_fd, &data->fb[0]);
  }

tests/i915/kms_psr2_su.c static void cleanup(data_t *data) · line 272

Quoted 10 lines
tests/i915/kms_psr2_su.c +10 -0
+static int check_psr2_support(data_t *data, enum pipe pipe, int x)
+{
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);

You could remove prepare/cleanup from here and have commond prepare/cleanup in the loop below. Would that work for you?

Quoted 56 lines

+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2); +       cleanup(data);

tests/i915/kms_psr2_su.c +4 -0
+
+       return x;
+}
+

 igt_main
 {
        data_t data = {};
+       enum pipe pipe;
+       int r;

        igt_fixture {
                struct itimerspec interval;
-               int r;

                data.drm_fd = drm_open_driver_master(DRIVER_INTEL); data.debugfs_fd = igt_debugfs_dir(data.drm_fd);

tests/i915/kms_psr2_su.c +0 -6
@@ -287,12 +304,6 @@ igt_main
                               "Error enabling PSR2\n");
                 data.op = FRONTBUFFER;
                 data.format = DRM_FORMAT_XRGB8888;
-               prepare(&data);
-               r = psr_wait_entry(data.debugfs_fd, PSR_MODE_2);
-               cleanup(&data);
-               if (!r)
-                       psr_print_debugfs(data.debugfs_fd);
-               igt_require_f(r, "PSR2 can not be enabled\n");


                /* blocking timerfd */
                data.change_screen_timerfd =
timerfd_create(CLOCK_MONOTONIC, 0);

tests/i915/kms_psr2_su.c +0 -0
@@ -312,23 +323,29 @@ igt_main
                 while (*format != DRM_FORMAT_INVALID) {
                         data.format = *format++;

                        igt_describe("Test that selective update works when screen changes");
-                       igt_subtest_f("%s-%s", op_str(data.op), igt_format_str(data.format)) {
-                               if (data.op == FRONTBUFFER && -
intel_display_ver(intel_get_drm_devid(data.drm_fd)) >= 12) { -                                       /*
-                                        * FIXME: Display 12+ platforms now have PSR2
-                                        * selective fetch enabled by default but we
-                                        * still can't properly handle frontbuffer
-                                        * rendering, so right it does full frame
-                                        * fetches at every frontbuffer rendering.
-                                        * So it is expected that this test will fail
-                                        * in display 12+ platform

Quoted 8 lines

for now.
-                                        */
-                                       igt_skip("PSR2 selective fetch is doing full frame fetches for frontbuffer rendering\n"); +                       igt_subtest_with_dynamic_f("%s-%s", op_str(data.op), igt_format_str(data.format)) {
+                               for_each_pipe_with_valid_output(&data .display, pipe, data.output) {

call prepare here.

Quoted 22 lines

+                                       if (check_psr2_support(&data, pipe, r)) {
+                                               igt_dynamic_f("pipe- %s", kmstest_pipe_name(pipe)) {
+                                                       if (data.op == FRONTBUFFER &&
+
intel_display_ver(intel_get_drm_devid(data.drm_fd)) >= 12) { +                                                               /* +                                                                *
FIXME: Display 12+ platforms now have PSR2
+                                                                * selective fetch enabled by default but we
+                                                                * still can't properly handle frontbuffer
+                                                                * rendering, so right it does full frame
+                                                                * fetches at every frontbuffer rendering.
+                                                                * So it is expected that this test will fail
+                                                                * in

Quoted 8 lines

display 12+ platform for now.
+                                                                */ +                                                               igt_s kip("PSR2 selective fetch is doing full frame fetches for frontbuffer rendering\n");
+                                                       } +                                                       prepare(&data );

Remove this one as well.

Quoted 2 lines

+                                                       run(&data); +                                                       cleanup(&data

And remove cleanup from here

Quoted 9 lines

);
+                                               } +                                       }
                                }
-                               prepare(&data);
-                               run(&data);
-                               cleanup(&data);
                        }
                }

Call cleanup here.

Quoted 1 line

        }

BR,

Jouni Högander

author
#3 lore raw

PATCH 2/2 tests/i915/kms_psr2_sf: Convert tests to dynamic

In reply to Jeevan B

Converting the existing subtests to dynamic subtests.

v2: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++------------
 1 file changed, 181 insertions(+), 78 deletions(-)
tests/i915/kms_psr2_sf.c +181 -78
index 6612587c..19efc5b9 100644
@@ -838,14 +838,31 @@ static void cleanup(data_t *data)
 	igt_remove_fb(data->drm_fd, &data->fb_test);
 }
 
+static int check_psr2_support(data_t *data, enum pipe pipe, int x)
+{
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);
+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2);
+       cleanup(data);
+
+       return x;
+}
+
 igt_main
 {
 	data_t data = {};
 	int i;
+	enum pipe pipe;
+	int r;
 
 	igt_fixture {
 		drmModeResPtr res;
-		int r;
 
 		data.drm_fd = drm_open_driver_master(DRIVER_INTEL);
 		data.debugfs_fd = igt_debugfs_dir(data.drm_fd);
@@ -888,131 +905,211 @@ igt_main
 
 	/* Verify primary plane selective fetch */
 	igt_describe("Test that selective fetch works on primary plane");
-	igt_subtest_f("primary-%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
-			data.damage_area_count = i;
-			data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-			prepare(&data);
-			run(&data);
-			cleanup(&data);
+	igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.damage_area_count = i;
+						data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
 		}
 	}
 
 	/* Verify primary plane selective fetch with big fb */
 	data.big_fb_test = 1;
 	igt_describe("Test that selective fetch works on primary plane with big fb");
-	igt_subtest_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-		for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
-			data.damage_area_count = i;
-			data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-			prepare(&data);
-			run(&data);
-			cleanup(&data);
+	igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.damage_area_count = i;
+						data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
 		}
 	}
 	data.big_fb_test = 0;
 
 	/* Verify overlay plane selective fetch */
 	igt_describe("Test that selective fetch works on overlay plane");
-	igt_subtest_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
-			data.damage_area_count = i;
-			data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-			prepare(&data);
-			run(&data);
-			cleanup(&data);
+	igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.damage_area_count = i;
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
 		}
 	}
 
 	/* Verify overlay plane selective fetch */
 	igt_describe("Test that selective fetch works on cursor plane");
-	igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-		data.damage_area_count = 1;
-		data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.damage_area_count = 1;
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
+		}
 	}
 
 	data.op = PLANE_MOVE_CONTINUOUS;
 	igt_describe("Test that selective fetch works on moving cursor plane (no update)");
-	igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-		data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
+		}
 	}
 
 	data.op = PLANE_MOVE_CONTINUOUS_EXCEED;
 	igt_describe("Test that selective fetch works on moving cursor plane exceeding partially visible area (no update)");
-	igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-		data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
+		}
 	}
 
 	data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY;
 	igt_describe("Test that selective fetch works on moving cursor plane exceeding fully visible area (no update)");
-	igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-		data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
+		}
 	}
 
 	/* Only for overlay plane */
 	data.op = PLANE_MOVE;
 	/* Verify overlay plane move selective fetch */
 	igt_describe("Test that selective fetch works on moving overlay plane");
-	igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) {
-		for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
-			data.pos = i;
-			data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-			prepare(&data);
-			run(&data);
-			cleanup(&data);
+	igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			 if (check_psr2_support(&data, pipe, r)) {
+				 igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
+						data.pos = i;
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				 }
+			 }
 		}
 	}
 
 	data.op = PLANE_MOVE_CONTINUOUS;
 	igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-	igt_subtest_f("overlay-%s-sf", op_str(data.op)) {
-		data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+					prepare(&data);
+					run(&data);
+					cleanup(&data);
+				}
+			}
+		}
 	}
 
 	data.op = PLANE_MOVE_CONTINUOUS_EXCEED;
 	igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)");
-	igt_subtest_f("overlay-%s-sf", op_str(data.op)) {
-		data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+					prepare(&data);
+					run(&data);
+					cleanup(&data);
+				}
+			}
+		}
 	}
 
 	data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY;
 	igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)");
-	igt_subtest_f("overlay-%s-sf", op_str(data.op)) {
-		data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-		prepare(&data);
-		run(&data);
-		cleanup(&data);
+	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+					prepare(&data);
+					run(&data);
+					cleanup(&data);
+				}
+			}
+		}
 	}
 
 	/* Verify primary plane selective fetch with overplay plane blended */
 	data.op = OVERLAY_PRIM_UPDATE;
 	igt_describe("Test that selective fetch works on primary plane "
 		     "with blended overlay plane");
-	igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
-			data.damage_area_count = i;
-			data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-			prepare(&data);
-			run(&data);
-			cleanup(&data);
+	igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+						data.damage_area_count = i;
+						data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
+				}
+			}
 		}
 	}
 
@@ -1023,12 +1120,18 @@ igt_main
 	data.op = PLANE_UPDATE_CONTINUOUS;
 	data.primary_format = DRM_FORMAT_NV12;
 	igt_describe("Test that selective fetch works on overlay plane");
-	igt_subtest_f("overlay-%s-sf", op_str(data.op)) {
-			data.damage_area_count = 1;
-			data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-			prepare(&data);
-			run(&data);
-			cleanup(&data);
+	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+		for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+			if (check_psr2_support(&data, pipe, r)) {
+				igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+					data.damage_area_count = 1;
+					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+					prepare(&data);
+					run(&data);
+					cleanup(&data);
+				}
+			}
+		}
 	}
 
 	igt_fixture {
Signature · 1 line
2.36.0
#4 lore raw

Re: [igt-dev] [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to dynamic

Quoted 19 lines · Jeevan B

Converting the existing subtests to dynamic subtests.

v2: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++---------- --

 1 file changed, 181 insertions(+), 78 deletions(-)
tests/i915/kms_psr2_sf.c +0 -0
index 6612587c..19efc5b9 100644
@@ -838,14 +838,31 @@ static void cleanup(data_t *data)
         igt_remove_fb(data->drm_fd, &data->fb_test);
  }

tests/i915/kms_psr2_sf.c static void cleanup(data_t *data) · line 850

Quoted 10 lines
tests/i915/kms_psr2_sf.c +10 -0
+static int check_psr2_support(data_t *data, enum pipe pipe, int x)
+{
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);

Same comment here as in that other patch. Share prepare/cleanup in where this check_psr2_support is called.

Also now I realized this function is doing more that just checking psr support. Maybe you should move

igt_display_reset(display);
output = data->output;
igt_output_set_pipe(output, pipe);

into prepare? Would this work for you?

Quoted 404 lines

+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2); +       cleanup(data);

tests/i915/kms_psr2_sf.c +4 -0
+
+       return x;
+}
+

 igt_main
 {
        data_t data = {};
        int i;
+       enum pipe pipe;
+       int r;

        igt_fixture {
                drmModeResPtr res;
-               int r;

                data.drm_fd = drm_open_driver_master(DRIVER_INTEL); data.debugfs_fd = igt_debugfs_dir(data.drm_fd);

tests/i915/kms_psr2_sf.c +0 -0
@@ -888,131 +905,211 @@ igt_main


        /* Verify primary plane selective fetch */ igt_describe("Test that selective fetch works on primary plane");
-       igt_subtest_f("primary-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify primary plane selective fetch with big fb */ data.big_fb_test = 1;
        igt_describe("Test that selective fetch works on primary plane with big fb");
-       igt_subtest_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }
        data.big_fb_test = 0;

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on cursor plane");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.damage_area_count = 1;
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = 1;
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving cursor plane (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving cursor plane exceeding partially visible area (no update)"); -       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving cursor plane exceeding fully visible area (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        /* Only for overlay plane */
        data.op = PLANE_MOVE;
        /* Verify overlay plane move selective fetch */ igt_describe("Test that selective fetch works on moving overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) { -                       data.pos = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                        if (check_psr2_support(&data, pipe, r)) { +                                igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
+                                               data.pos = i; +                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                                }
+                        }
                }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        /* Verify primary plane selective fetch with overplay plane blended */
        data.op = OVERLAY_PRIM_UPDATE;
        igt_describe("Test that selective fetch works on primary plane "
                     "with blended overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

tests/i915/kms_psr2_sf.c +0 -0
@@ -1023,12 +1120,18 @@ igt_main
         data.op = PLANE_UPDATE_CONTINUOUS;
         data.primary_format = DRM_FORMAT_NV12;

        igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -                       data.damage_area_count = 1;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.damage_area_count = 1; +                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        igt_fixture {

author
#5 lore raw

Re: [igt-dev] [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to dynamic

Quoted 42 lines

-----Original Message-----
From: Hogander, Jouni <[email protected]>
Sent: Friday, September 9, 2022 5:07 PM
To: [email protected]; B, Jeevan <[email protected]>
Subject: Re: [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to dynamic

Quoted 18 lines · Jeevan B

Converting the existing subtests to dynamic subtests.

v2: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++---------- --

 1 file changed, 181 insertions(+), 78 deletions(-)
tests/i915/kms_psr2_sf.c index renamed from tests/i915/kms_psr2_sf.c +0 -0

6612587c..19efc5b9 100644

tests/i915/kms_psr2_sf.c +0 -0
@@ -838,14 +838,31 @@ static void cleanup(data_t *data)
         igt_remove_fb(data->drm_fd, &data->fb_test);
  }

tests/i915/kms_psr2_sf.c static void cleanup(data_t *data) · line 849

Quoted 10 lines
tests/i915/kms_psr2_sf.c +9 -0
 
+static int check_psr2_support(data_t *data, enum pipe pipe, int x) {
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);

Same comment here as in that other patch. Share prepare/cleanup in where this check_psr2_support is called.

Quoted 3 lines

Also now I realized this function is doing more that just checking psr support. Maybe you should move

Hi,

I tried to change as suggested.
+static void prepare(data_t *data, enum pipe pipe)

 {
        igt_plane_t *primary, *sprite = NULL, *cursor = NULL;
        int fb_w, fb_h, x, y, view_w, view_h;
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
        if (data->big_fb_test) {
                fb_w = data->big_fb_width;

also share prepare and clean for check_psr2_support.
In couple of cases tests is failing due to "psr_active_check" failed and also "No space left on device".

Tried few tweaks didn't work. Any suggestion ??

Thanks
Jeevan B

Quoted 410 lines

igt_display_reset(display);
output = data->output;
igt_output_set_pipe(output, pipe);

into prepare? Would this work for you?

Quoted 404 lines
tests/i915/kms_psr2_sf.c +6 -0
+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2);
+       cleanup(data);
+
+       return x;
+}
+

 igt_main
 {
        data_t data = {};
        int i;
+       enum pipe pipe;
+       int r;

        igt_fixture {
                drmModeResPtr res;
-               int r;

                data.drm_fd = drm_open_driver_master(DRIVER_INTEL); data.debugfs_fd = igt_debugfs_dir(data.drm_fd); @@ -888,131 +905,211 @@ igt_main

        /* Verify primary plane selective fetch */ igt_describe("Test that selective fetch works on primary plane");
-       igt_subtest_f("primary-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify primary plane selective fetch with big fb */ data.big_fb_test = 1;
        igt_describe("Test that selective fetch works on primary plane with big fb");
-       igt_subtest_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
-                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }
        data.big_fb_test = 0;

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on cursor plane");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.damage_area_count = 1;
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = 1;
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS;
        igt_describe("Test that selective fetch works on moving cursor plane (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving cursor plane exceeding partially visible area (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving cursor plane exceeding fully visible area (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        /* Only for overlay plane */
        data.op = PLANE_MOVE;
        /* Verify overlay plane move selective fetch */ igt_describe("Test that selective fetch works on moving overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) { -                       data.pos = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                        if (check_psr2_support(&data, pipe, r)) { +                                igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
+                                               data.pos = i; +                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                                }
+                        }
                }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        /* Verify primary plane selective fetch with overplay plane blended */
        data.op = OVERLAY_PRIM_UPDATE;
        igt_describe("Test that selective fetch works on primary plane "
                     "with blended overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
-                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

tests/i915/kms_psr2_sf.c +0 -0
@@ -1023,12 +1120,18 @@ igt_main
         data.op = PLANE_UPDATE_CONTINUOUS;
         data.primary_format = DRM_FORMAT_NV12;

        igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -                       data.damage_area_count = 1;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.damage_area_count = 1; +                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        igt_fixture {

#6 lore raw

Re: [igt-dev] [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to dynamic

Quoted 68 lines · Jeevan
Quoted 47 lines

-----Original Message-----
From: Hogander, Jouni <[email protected]>
Sent: Friday, September 9, 2022 5:07 PM
To: [email protected]; B, Jeevan <[email protected]>
Subject: Re: [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to
dynamic

Quoted 21 lines · Jeevan B

Converting the existing subtests to dynamic subtests.

v2: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++------
----
--

 1 file changed, 181 insertions(+), 78 deletions(-)
tests/i915/kms_psr2_sf.c +0 -0

index
6612587c..19efc5b9 100644

tests/i915/kms_psr2_sf.c +0 -0
@@ -838,14 +838,31 @@ static void cleanup(data_t *data)
         igt_remove_fb(data->drm_fd, &data->fb_test);
  }
 

tests/i915/kms_psr2_sf.c static void cleanup(data_t *data) · line 850

Quoted 10 lines
tests/i915/kms_psr2_sf.c +9 -0
+static int check_psr2_support(data_t *data, enum pipe pipe, int
 x) {
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);

Same comment here as in that other patch. Share prepare/cleanup in where
this check_psr2_support is called.

Quoted 4 lines

Also now I realized this function is doing more that just checking psr
support. Maybe you should move

Hi,

I tried to change as suggested.
+static void prepare(data_t *data, enum pipe pipe) {
        igt_plane_t *primary, *sprite = NULL, *cursor = NULL; int fb_w, fb_h, x, y, view_w, view_h;
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);

        if (data->big_fb_test) {
                fb_w = data->big_fb_width;

Quoted 6 lines

also share prepare and clean for check_psr2_support.
In couple of cases tests is failing due to "psr_active_check" failed and also
"No space left on device".

Tried few tweaks didn't work. Any suggestion ??

Ok, this is probably because prepare is depending on damage_area_count and test_plane_id. Let's keep this part as it was in your last patch. Sorry for confusion here. My bad.

I found couple of other issues in your patch. I will comment these in separate reply to your patch.

Quoted 473 lines

Thanks
Jeevan B

Quoted 468 lines

igt_display_reset(display);
output = data->output;
igt_output_set_pipe(output, pipe);

into prepare? Would this work for you?

Quoted 462 lines
tests/i915/kms_psr2_sf.c +6 -0
+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2);
+       cleanup(data);
+
+       return x;
+}
+

 igt_main
 {
        data_t data = {};
        int i;
+       enum pipe pipe;
+       int r;

        igt_fixture {
                drmModeResPtr res;
-               int r;

                data.drm_fd = drm_open_driver_master(DRIVER_INTEL);
                data.debugfs_fd = igt_debugfs_dir(data.drm_fd); @@
-888,131 +905,211 @@ igt_main

        /* Verify primary plane selective fetch */ igt_describe("Test that selective fetch works on primary plane");
-       igt_subtest_f("primary-%s-sf-dmg-area", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_ coun
t = i;
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify primary plane selective fetch with big fb */ data.big_fb_test = 1;
        igt_describe("Test that selective fetch works on primary plane
with big fb");
-       igt_subtest_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big- fb",
op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_ coun
t = i;
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }
        data.big_fb_test = 0;

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_ coun
t = i;
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on cursor plane");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.damage_area_count = 1;
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_ coun
t = 1;
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving cursor
plane (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving cursor
plane exceeding partially visible area (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving cursor
plane exceeding fully visible area (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        /* Only for overlay plane */
        data.op = PLANE_MOVE;
        /* Verify overlay plane move selective fetch */ igt_describe("Test that selective fetch works on moving overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
-                       data.pos = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op))
{
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                        if (check_psr2_support(&data, pipe, r)) {
+                                igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = POS_TOP_LEFT; i <=
POS_BOTTOM_RIGHT ; i++) {
+                                               data.pos = i; +                                               data.test_plane_i d =
DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                                }
+                        }
                }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op))
{
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data); +                                       run(&data);
+                                       cleanup(&data); +                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op))
{
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data); +                                       run(&data);
+                                       cleanup(&data); +                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op))
{
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data); +                                       run(&data);
+                                       cleanup(&data); +                               }
+                       }
+               }
        }

        /* Verify primary plane selective fetch with overplay plane
blended */
        data.op = OVERLAY_PRIM_UPDATE; igt_describe("Test that selective fetch works on primary plane
"
                     "with blended overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op))
{
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_ coun
t = i;
+                                               data.test_plane_i d =
DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

tests/i915/kms_psr2_sf.c +0 -0
@@ -1023,12 +1120,18 @@ igt_main
         data.op = PLANE_UPDATE_CONTINUOUS;
         data.primary_format = DRM_FORMAT_NV12;

        igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -                       data.damage_area_count = 1;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op))
{
+               for_each_pipe_with_valid_output(&data.display, pipe,
data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.damage_area_count = 1;
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data); +                                       run(&data);
+                                       cleanup(&data); +                               }
+                       }
+               }
        }

        igt_fixture {

#7 lore raw

Re: [igt-dev] [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to dynamic

In reply to Jeevan B
Quoted 18 lines · Jeevan B

Converting the existing subtests to dynamic subtests.

v2: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++---------- --

 1 file changed, 181 insertions(+), 78 deletions(-)
tests/i915/kms_psr2_sf.c +0 -0
index 6612587c..19efc5b9 100644
@@ -838,14 +838,31 @@ static void cleanup(data_t *data)
         igt_remove_fb(data->drm_fd, &data->fb_test);
  }
Quoted 2 lines


+static int check_psr2_support(data_t *data, enum pipe pipe, int x)

I think you can drop int x.

Quoted 4 lines
tests/i915/kms_psr2_sf.c +4 -0
+{
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+

tests/i915/kms_psr2_sf.c static void cleanup(data_t *data) · line 855

Quoted 10 lines
tests/i915/kms_psr2_sf.c +10 -0
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);
+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2);
+       cleanup(data);
+
+       return x;
+}

How about checking psr2 support once in fixture:

...
int pipes[IGT_MAX_PIPES];
int n_pipes = 0;
...

for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
	if (check_psr2_support(&data, pipe) {
		pipes[n_pipes] = pipe;
		n_pipes++;
	}
}

Then just iterate pipes array later instead of rechecking for each testcase.

Quoted 124 lines

+
 igt_main
 {
        data_t data = {};
        int i;
+       enum pipe pipe;
+       int r;

        igt_fixture {
                drmModeResPtr res;
-               int r;

                data.drm_fd = drm_open_driver_master(DRIVER_INTEL); data.debugfs_fd = igt_debugfs_dir(data.drm_fd);

tests/i915/kms_psr2_sf.c +0 -0
@@ -888,131 +905,211 @@ igt_main


        /* Verify primary plane selective fetch */ igt_describe("Test that selective fetch works on primary plane");
-       igt_subtest_f("primary-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify primary plane selective fetch with big fb */ data.big_fb_test = 1;
        igt_describe("Test that selective fetch works on primary plane with big fb");
-       igt_subtest_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }
        data.big_fb_test = 0;

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on cursor plane");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.damage_area_count = 1;
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

No need to iterate damage areas.

Quoted 21 lines

+                                               data.damage_area_coun t = 1;
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving cursor plane (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

Same here

Quoted 19 lines

+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving cursor plane exceeding partially visible area (no update)"); -       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

Here as well.

Quoted 19 lines

+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving cursor plane exceeding fully visible area (no update)"); -       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

and here.

Quoted 184 lines

+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        /* Only for overlay plane */
        data.op = PLANE_MOVE;
        /* Verify overlay plane move selective fetch */ igt_describe("Test that selective fetch works on moving overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) { -                       data.pos = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                        if (check_psr2_support(&data, pipe, r)) { +                                igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
+                                               data.pos = i; +                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                                }
+                        }
                }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        /* Verify primary plane selective fetch with overplay plane blended */
        data.op = OVERLAY_PRIM_UPDATE;
        igt_describe("Test that selective fetch works on primary plane "
                     "with blended overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

tests/i915/kms_psr2_sf.c +0 -0
@@ -1023,12 +1120,18 @@ igt_main
         data.op = PLANE_UPDATE_CONTINUOUS;
         data.primary_format = DRM_FORMAT_NV12;

        igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -                       data.damage_area_count = 1;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.damage_area_count = 1; +                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        igt_fixture {

#8 lore raw

Re: [igt-dev] [PATCH i-g-t 2/2] tests/i915/kms_psr2_sf: Convert tests to dynamic

Quoted 52 lines · Jouni
Quoted 18 lines · Jeevan B

Converting the existing subtests to dynamic subtests.

v2: Check for pipe supporting PSR2 or not and then add to dynamic subtest. (Jouni)

---
 tests/i915/kms_psr2_sf.c | 259 +++++++++++++++++++++++++++---------- --

 1 file changed, 181 insertions(+), 78 deletions(-)
tests/i915/kms_psr2_sf.c +0 -0
index 6612587c..19efc5b9 100644
@@ -838,14 +838,31 @@ static void cleanup(data_t *data)
         igt_remove_fb(data->drm_fd, &data->fb_test);
  }
Quoted 2 lines


+static int check_psr2_support(data_t *data, enum pipe pipe, int x)

I think you can drop int x.

Quoted 4 lines
tests/i915/kms_psr2_sf.c +4 -0
+{
+       igt_output_t *output;
+       igt_display_t *display = &data->display;
+

tests/i915/kms_psr2_sf.c static void cleanup(data_t *data) · line 855

Quoted 10 lines
tests/i915/kms_psr2_sf.c +10 -0
+       igt_display_reset(display);
+       output = data->output;
+       igt_output_set_pipe(output, pipe);
+
+       prepare(data);
+       x = psr_wait_entry(data->debugfs_fd, PSR_MODE_2);
+       cleanup(data);
+
+       return x;
+}

How about checking psr2 support once in fixture:

...
int pipes[IGT_MAX_PIPES];
int n_pipes = 0;
...

for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
	if (check_psr2_support(&data, pipe) {
		pipes[n_pipes] = pipe;
		n_pipes++;
	}
}
Quoted 2 lines

Then just iterate pipes array later instead of rechecking for each testcase.

Drive-by correction: for_each_pipe_with_single_output.

Signature · 1 line
Petri Latvala
Quoted 413 lines
Quoted 125 lines

+
 igt_main
 {
        data_t data = {};
        int i;
+       enum pipe pipe;
+       int r;

        igt_fixture {
                drmModeResPtr res;
-               int r;

                data.drm_fd = drm_open_driver_master(DRIVER_INTEL); data.debugfs_fd = igt_debugfs_dir(data.drm_fd);

tests/i915/kms_psr2_sf.c +0 -0
@@ -888,131 +905,211 @@ igt_main


        /* Verify primary plane selective fetch */ igt_describe("Test that selective fetch works on primary plane");
-       igt_subtest_f("primary-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify primary plane selective fetch with big fb */ data.big_fb_test = 1;
        igt_describe("Test that selective fetch works on primary plane with big fb");
-       igt_subtest_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }
        data.big_fb_test = 0;

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

        /* Verify overlay plane selective fetch */ igt_describe("Test that selective fetch works on cursor plane");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.damage_area_count = 1;
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

No need to iterate damage areas.

Quoted 21 lines

+                                               data.damage_area_coun t = 1;
+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving cursor plane (no update)");
-       igt_subtest_f("cursor-%s-sf", op_str(data.op)) {
-               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

Same here

Quoted 19 lines

+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving cursor plane exceeding partially visible area (no update)"); -       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

Here as well.

Quoted 19 lines

+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving cursor plane exceeding fully visible area (no update)"); -       igt_subtest_f("cursor-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_CURSOR; -               prepare(&data);
-               run(&data);
-               cleanup(&data);

Quoted 8 lines

+       igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) { +               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {

and here.

Quoted 184 lines

+                                               data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
+               }
        }

        /* Only for overlay plane */
        data.op = PLANE_MOVE;
        /* Verify overlay plane move selective fetch */ igt_describe("Test that selective fetch works on moving overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) { -                       data.pos = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                        if (check_psr2_support(&data, pipe, r)) { +                                igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = POS_TOP_LEFT; i <= POS_BOTTOM_RIGHT ; i++) {
+                                               data.pos = i; +                                               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                                }
+                        }
                }
        }

        data.op = PLANE_MOVE_CONTINUOUS; igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED; igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY; igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)"); -       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -               data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -               prepare(&data);
-               run(&data);
-               cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        /* Verify primary plane selective fetch with overplay plane blended */
        data.op = OVERLAY_PRIM_UPDATE;
        igt_describe("Test that selective fetch works on primary plane "
                     "with blended overlay plane");
-       igt_subtest_f("%s-sf-dmg-area", op_str(data.op)) { -               for (i = 1; i <= MAX_DAMAGE_AREAS; i++) { -                       data.damage_area_count = i;
-                       data.test_plane_id = DRM_PLANE_TYPE_PRIMARY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       for (i = 1; i <= MAX_DAMAGE_AREAS; i++) {
+                                               data.damage_area_coun t = i;
+                                               data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+                                               prepare(&data); +                                               run(&data); +                                               cleanup(&data); +                                       }
+                               }
+                       }
                }
        }

tests/i915/kms_psr2_sf.c +0 -0
@@ -1023,12 +1120,18 @@ igt_main
         data.op = PLANE_UPDATE_CONTINUOUS;
         data.primary_format = DRM_FORMAT_NV12;

        igt_describe("Test that selective fetch works on overlay plane");
-       igt_subtest_f("overlay-%s-sf", op_str(data.op)) { -                       data.damage_area_count = 1;
-                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY; -                       prepare(&data);
-                       run(&data);
-                       cleanup(&data);
+       igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
+               for_each_pipe_with_valid_output(&data.display, pipe, data.output) {
+                       if (check_psr2_support(&data, pipe, r)) { +                               igt_dynamic_f("pipe-%s", kmstest_pipe_name(pipe)) {
+                                       data.damage_area_count = 1; +                                       data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+                                       prepare(&data);
+                                       run(&data);
+                                       cleanup(&data);
+                               }
+                       }
+               }
        }

        igt_fixture {

#9 lore raw

[igt-dev] ✓ Fi.CI.BAT: success for Convert PSR2 sf & su test to dynamic

In reply to Jeevan B
== Series Details ==

== Series Details ==

Series: Convert PSR2 sf & su test to dynamic
URL : https://patchwork.freedesktop.org/series/108299/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_12094 -> IGTPW_7756
====================================================

Summary
-------

**SUCCESS**

No regressions found.

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

Participating hosts (32 -> 40)
------------------------------

Additional (9): bat-dg1-5 bat-adlm-1 bat-dg2-9 bat-adlp-6 bat-adlp-4 bat-rplp-1 bat-rpls-1 bat-rpls-2 bat-dg2-11
Missing (1): fi-bdw-samus

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

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

### IGT changes ###

#### Issues hit ####

* igt@fbdev@nullptr:
- bat-dg1-5: NOTRUN -> [SKIP][1] ([i915#2582]) +4 similar issues
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@fbdev@read:
- bat-adlp-4: NOTRUN -> [SKIP][2] ([i915#2582]) +4 similar issues
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]

* igt@gem_lmem_swapping@parallel-random-engines:
- bat-adlp-4: NOTRUN -> [SKIP][3] ([i915#4613]) +3 similar issues
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]

* igt@gem_mmap@basic:
- bat-dg1-5: NOTRUN -> [SKIP][4] ([i915#4083])
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@gem_tiled_blits@basic:
- bat-dg1-5: NOTRUN -> [SKIP][5] ([i915#4077]) +2 similar issues
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@gem_tiled_pread_basic:
- bat-dg1-5: NOTRUN -> [SKIP][6] ([i915#4079]) +1 similar issue
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@gem_tiled_pread_basic.html
- bat-adlp-4: NOTRUN -> [SKIP][7] ([i915#3282])
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@gem_tiled_pread_basic.html

* igt@i915_pm_backlight@basic-brightness:
- bat-adlp-4: NOTRUN -> [SKIP][8] ([i915#1155])
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][9] ([i915#1155])
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@i915_pm_rps@basic-api:
- bat-adlp-4: NOTRUN -> [SKIP][10] ([i915#6621])
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][11] ([i915#6621])
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@i915_selftest@live@gem:
- fi-pnv-d510: NOTRUN -> [DMESG-FAIL][12] ([i915#4528])
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-pnv-d510/igt@i915_selftest@[email protected]

* igt@i915_selftest@live@hangcheck:
- fi-hsw-g3258: [PASS][13] -> [INCOMPLETE][14] ([i915#3303] / [i915#4785])
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/fi-hsw-g3258/igt@i915_selftest@[email protected]
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-hsw-g3258/igt@i915_selftest@[email protected]
- bat-dg1-5: NOTRUN -> [DMESG-FAIL][15] ([i915#4494] / [i915#4957])
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@i915_selftest@[email protected]

* igt@i915_suspend@basic-s2idle-without-i915:
- bat-dg1-5: NOTRUN -> [INCOMPLETE][16] ([i915#6011])
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_addfb_basic@basic-x-tiled-legacy:
- bat-dg1-5: NOTRUN -> [SKIP][17] ([i915#4212]) +7 similar issues
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_addfb_basic@basic-y-tiled-legacy:
- bat-dg1-5: NOTRUN -> [SKIP][18] ([i915#4215])
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_busy@basic:
- bat-dg1-5: NOTRUN -> [SKIP][19] ([i915#1845] / [i915#4303])
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_chamelium@common-hpd-after-suspend:
- fi-bsw-kefka: NOTRUN -> [SKIP][20] ([fdo#109271] / [fdo#111827])
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-bsw-kefka/igt@[email protected]

* igt@kms_chamelium@dp-crc-fast:
- bat-adlp-4: NOTRUN -> [SKIP][21] ([fdo#111827]) +8 similar issues
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][22] ([fdo#111827]) +7 similar issues
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_flip@basic-flip-vs-wf_vblank:
- bat-adlp-4: NOTRUN -> [SKIP][23] ([i915#3637]) +3 similar issues
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@kms_flip@basic-flip-vs-wf_vblank.html

* igt@kms_force_connector_basic@force-load-detect:
- bat-adlp-4: NOTRUN -> [SKIP][24] ([i915#4093]) +3 similar issues
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][25] ([fdo#109285])
[25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_frontbuffer_tracking@basic:
- bat-adlp-4: NOTRUN -> [SKIP][26] ([i915#4342])
[26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]

* igt@kms_pipe_crc_basic@nonblocking-crc:
- bat-dg1-5: NOTRUN -> [SKIP][27] ([i915#4078]) +13 similar issues
[27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@kms_pipe_crc_basic@read-crc-frame-sequence:
- bat-adlp-4: NOTRUN -> [SKIP][28] ([i915#3546]) +10 similar issues
[28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]

* igt@kms_psr@primary_page_flip:
- bat-dg1-5: NOTRUN -> [SKIP][29] ([i915#1072] / [i915#4078]) +3 similar issues
[29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@kms_psr@primary_page_flip.html

* igt@kms_psr@sprite_plane_onoff:
- bat-adlp-4: NOTRUN -> [SKIP][30] ([i915#1072]) +3 similar issues
[30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@kms_psr@sprite_plane_onoff.html

* igt@kms_setmode@basic-clone-single-crtc:
- bat-dg1-5: NOTRUN -> [SKIP][31] ([i915#3555])
[31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]
- bat-adlp-4: NOTRUN -> [SKIP][32] ([i915#3555] / [i915#4579])
[32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]

* igt@prime_vgem@basic-fence-flip:
- bat-adlp-4: NOTRUN -> [SKIP][33] ([fdo#109295] / [i915#3546] / [i915#3708])
[33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][34] ([i915#1845] / [i915#3708])
[34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@prime_vgem@basic-fence-read:
- bat-dg1-5: NOTRUN -> [SKIP][35] ([i915#3708]) +2 similar issues
[35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@prime_vgem@basic-gtt:
- bat-dg1-5: NOTRUN -> [SKIP][36] ([i915#3708] / [i915#4077]) +1 similar issue
[36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@prime_vgem@basic-userptr:
- bat-adlp-4: NOTRUN -> [SKIP][37] ([fdo#109295] / [i915#3301] / [i915#3708])
[37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][38] ([i915#3708] / [i915#4873])
[38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]

* igt@prime_vgem@basic-write:
- bat-adlp-4: NOTRUN -> [SKIP][39] ([fdo#109295] / [i915#3291] / [i915#3708]) +2 similar issues
[39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-adlp-4/igt@[email protected]

* igt@runner@aborted:
- fi-glk-dsi: NOTRUN -> [FAIL][40] ([i915#4312] / [i915#6599])
[40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-glk-dsi/igt@[email protected]
- bat-dg1-5: NOTRUN -> [FAIL][41] ([i915#4312] / [i915#5257])
[41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/bat-dg1-5/igt@[email protected]
- fi-bdw-5557u: NOTRUN -> [FAIL][42] ([i915#4312])
[42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-bdw-5557u/igt@[email protected]
- fi-hsw-g3258: NOTRUN -> [FAIL][43] ([fdo#109271] / [i915#4312] / [i915#6246])
[43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-hsw-g3258/igt@[email protected]

#### Possible fixes ####

* igt@i915_selftest@live@execlists:
- fi-bsw-kefka: [INCOMPLETE][44] ([i915#5847]) -> [PASS][45]
[44]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/fi-bsw-kefka/igt@i915_selftest@[email protected]
[45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-bsw-kefka/igt@i915_selftest@[email protected]

* igt@i915_selftest@live@requests:
- fi-pnv-d510: [DMESG-FAIL][46] ([i915#4528]) -> [PASS][47]
[46]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/fi-pnv-d510/igt@i915_selftest@[email protected]
[47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/fi-pnv-d510/igt@i915_selftest@[email protected]

{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#109285]: https://bugs.freedesktop.org/show_bug.cgi?id=109285
[fdo#109295]: https://bugs.freedesktop.org/show_bug.cgi?id=109295
[fdo#111827]: https://bugs.freedesktop.org/show_bug.cgi?id=111827
[i915#1072]: https://gitlab.freedesktop.org/drm/intel/issues/1072
[i915#1155]: https://gitlab.freedesktop.org/drm/intel/issues/1155
[i915#1845]: https://gitlab.freedesktop.org/drm/intel/issues/1845
[i915#1849]: https://gitlab.freedesktop.org/drm/intel/issues/1849
[i915#2582]: https://gitlab.freedesktop.org/drm/intel/issues/2582
[i915#2867]: https://gitlab.freedesktop.org/drm/intel/issues/2867
[i915#3282]: https://gitlab.freedesktop.org/drm/intel/issues/3282
[i915#3291]: https://gitlab.freedesktop.org/drm/intel/issues/3291
[i915#3301]: https://gitlab.freedesktop.org/drm/intel/issues/3301
[i915#3303]: https://gitlab.freedesktop.org/drm/intel/issues/3303
[i915#3546]: https://gitlab.freedesktop.org/drm/intel/issues/3546
[i915#3555]: https://gitlab.freedesktop.org/drm/intel/issues/3555
[i915#3595]: https://gitlab.freedesktop.org/drm/intel/issues/3595
[i915#3637]: https://gitlab.freedesktop.org/drm/intel/issues/3637
[i915#3708]: https://gitlab.freedesktop.org/drm/intel/issues/3708
[i915#4077]: https://gitlab.freedesktop.org/drm/intel/issues/4077
[i915#4078]: https://gitlab.freedesktop.org/drm/intel/issues/4078
[i915#4079]: https://gitlab.freedesktop.org/drm/intel/issues/4079
[i915#4083]: https://gitlab.freedesktop.org/drm/intel/issues/4083
[i915#4093]: https://gitlab.freedesktop.org/drm/intel/issues/4093
[i915#4103]: https://gitlab.freedesktop.org/drm/intel/issues/4103
[i915#4212]: https://gitlab.freedesktop.org/drm/intel/issues/4212
[i915#4213]: https://gitlab.freedesktop.org/drm/intel/issues/4213
[i915#4215]: https://gitlab.freedesktop.org/drm/intel/issues/4215
[i915#4258]: https://gitlab.freedesktop.org/drm/intel/issues/4258
[i915#4303]: https://gitlab.freedesktop.org/drm/intel/issues/4303
[i915#4312]: https://gitlab.freedesktop.org/drm/intel/issues/4312
[i915#4342]: https://gitlab.freedesktop.org/drm/intel/issues/4342
[i915#4494]: https://gitlab.freedesktop.org/drm/intel/issues/4494
[i915#4528]: https://gitlab.freedesktop.org/drm/intel/issues/4528
[i915#4579]: https://gitlab.freedesktop.org/drm/intel/issues/4579
[i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
[i915#4785]: https://gitlab.freedesktop.org/drm/intel/issues/4785
[i915#4817]: https://gitlab.freedesktop.org/drm/intel/issues/4817
[i915#4873]: https://gitlab.freedesktop.org/drm/intel/issues/4873
[i915#4957]: https://gitlab.freedesktop.org/drm/intel/issues/4957
[i915#5190]: https://gitlab.freedesktop.org/drm/intel/issues/5190
[i915#5257]: https://gitlab.freedesktop.org/drm/intel/issues/5257
[i915#5274]: https://gitlab.freedesktop.org/drm/intel/issues/5274
[i915#5847]: https://gitlab.freedesktop.org/drm/intel/issues/5847
[i915#6011]: https://gitlab.freedesktop.org/drm/intel/issues/6011
[i915#6246]: https://gitlab.freedesktop.org/drm/intel/issues/6246
[i915#6367]: https://gitlab.freedesktop.org/drm/intel/issues/6367
[i915#6599]: https://gitlab.freedesktop.org/drm/intel/issues/6599
[i915#6621]: https://gitlab.freedesktop.org/drm/intel/issues/6621
[i915#6641]: https://gitlab.freedesktop.org/drm/intel/issues/6641
[i915#6730]: https://gitlab.freedesktop.org/drm/intel/issues/6730

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

* CI: CI-20190529 -> None
* IGT: IGT_6648 -> IGTPW_7756

CI-20190529: 20190529
CI_DRM_12094: 2c2f1d1ab12efd051cffcd740978476c96c26d0d @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_7756: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/index.html
IGT_6648: 3c9079c0b97445fbfc903b9c5a1d69707b80af80 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

== Logs ==

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

#10 lore raw

[igt-dev] ✓ Fi.CI.IGT: success for Convert PSR2 sf & su test to dynamic

In reply to Jeevan B
== Series Details ==

== Series Details ==

Series: Convert PSR2 sf & su test to dynamic
URL : https://patchwork.freedesktop.org/series/108299/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_12094_full -> IGTPW_7756_full
====================================================

Summary
-------

**WARNING**

Minor unknown changes coming with IGTPW_7756_full need to be verified manually.

If you think the reported changes have nothing to do with the changes introduced in IGTPW_7756_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_7756/index.html

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

Missing (3): pig-skl-6260u pig-kbl-iris pig-glk-j5005

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

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

### IGT changes ###

#### Warnings ####

* igt@kms_psr2_su@page_flip-nv12:
- shard-tglb: [SKIP][1] ([i915#1911]) -> [SKIP][2] +3 similar issues
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb7/igt@kms_psr2_su@page_flip-nv12.html
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb6/igt@kms_psr2_su@page_flip-nv12.html

New tests
---------

New tests have been introduced between CI_DRM_12094_full and IGTPW_7756_full:

### New IGT tests (3) ###

* igt@kms_psr2_su@frontbuffer-xrgb8888@pipe-a:
- Statuses : 1 pass(s)
- Exec time: [0.60] s

* igt@kms_psr2_su@frontbuffer-xrgb8888@pipe-b:
- Statuses : 1 pass(s)
- Exec time: [0.29] s

* igt@kms_psr2_su@frontbuffer-xrgb8888@pipe-c:
- Statuses : 1 pass(s)
- Exec time: [0.29] s

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

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

### IGT changes ###

#### Issues hit ####

* igt@drm_buddy@all:
- shard-iclb: NOTRUN -> [SKIP][3] ([i915#6433])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb5/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][4] ([i915#6433])
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb5/igt@[email protected]

* igt@gem_ctx_isolation@preservation-s3@vecs0:
- shard-apl: [PASS][5] -> [DMESG-WARN][6] ([i915#180])
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl7/igt@gem_ctx_isolation@[email protected]
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl2/igt@gem_ctx_isolation@[email protected]

* igt@gem_ctx_persistence@legacy-engines-queued:
- shard-snb: NOTRUN -> [SKIP][7] ([fdo#109271] / [i915#1099])
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-snb5/igt@[email protected]

* igt@gem_eio@unwedge-stress:
- shard-tglb: [PASS][8] -> [FAIL][9] ([i915#5784])
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb3/igt@[email protected]
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb2/igt@[email protected]

* igt@gem_exec_fair@basic-pace@vcs0:
- shard-glk: [PASS][10] -> [FAIL][11] ([i915#2842]) +1 similar issue
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk2/igt@gem_exec_fair@[email protected]
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk2/igt@gem_exec_fair@[email protected]

* igt@gem_lmem_swapping@heavy-multi:
- shard-apl: NOTRUN -> [SKIP][12] ([fdo#109271] / [i915#4613])
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl3/igt@[email protected]

* igt@gen9_exec_parse@allowed-all:
- shard-glk: [PASS][13] -> [DMESG-WARN][14] ([i915#5566] / [i915#716])
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk3/igt@[email protected]
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk1/igt@[email protected]

* igt@i915_pm_dc@dc5-psr:
- shard-tglb: [PASS][15] -> [FAIL][16] ([i915#3989])
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb5/igt@[email protected]
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb5/igt@[email protected]

* igt@i915_pm_dc@dc9-dpms:
- shard-apl: [PASS][17] -> [SKIP][18] ([fdo#109271])
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl3/igt@[email protected]
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl8/igt@[email protected]

* igt@kms_big_fb@4-tiled-addfb-size-offset-overflow:
- shard-tglb: NOTRUN -> [SKIP][19] ([i915#5286])
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb3/igt@[email protected]

* igt@kms_ccs@pipe-a-crc-primary-rotation-180-4_tiled_dg2_rc_ccs_cc:
- shard-tglb: NOTRUN -> [SKIP][20] ([i915#3689] / [i915#6095])
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb3/igt@kms_ccs@pipe-a-crc-primary-rotation-180-4_tiled_dg2_rc_ccs_cc.html

* igt@kms_ccs@pipe-c-bad-aux-stride-y_tiled_gen12_rc_ccs_cc:
- shard-apl: NOTRUN -> [SKIP][21] ([fdo#109271] / [i915#3886]) +2 similar issues
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl8/igt@kms_ccs@pipe-c-bad-aux-stride-y_tiled_gen12_rc_ccs_cc.html

* igt@kms_ccs@pipe-c-bad-pixel-format-yf_tiled_ccs:
- shard-apl: NOTRUN -> [SKIP][22] ([fdo#109271]) +83 similar issues
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl6/igt@kms_ccs@pipe-c-bad-pixel-format-yf_tiled_ccs.html

* igt@kms_ccs@pipe-d-bad-aux-stride-y_tiled_gen12_mc_ccs:
- shard-tglb: NOTRUN -> [SKIP][23] ([i915#3689]) +1 similar issue
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb5/igt@kms_ccs@pipe-d-bad-aux-stride-y_tiled_gen12_mc_ccs.html

* igt@kms_ccs@pipe-d-bad-rotation-90-yf_tiled_ccs:
- shard-iclb: NOTRUN -> [SKIP][24] ([fdo#109278])
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb8/igt@kms_ccs@pipe-d-bad-rotation-90-yf_tiled_ccs.html
- shard-tglb: NOTRUN -> [SKIP][25] ([fdo#111615] / [i915#3689])
[25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb1/igt@kms_ccs@pipe-d-bad-rotation-90-yf_tiled_ccs.html

* igt@kms_chamelium@hdmi-crc-single:
- shard-iclb: NOTRUN -> [SKIP][26] ([fdo#109284] / [fdo#111827])
[26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb6/igt@[email protected]
- shard-snb: NOTRUN -> [SKIP][27] ([fdo#109271] / [fdo#111827])
[27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-snb6/igt@[email protected]
- shard-apl: NOTRUN -> [SKIP][28] ([fdo#109271] / [fdo#111827]) +2 similar issues
[28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl7/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][29] ([fdo#109284] / [fdo#111827]) +1 similar issue
[29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb5/igt@[email protected]
- shard-glk: NOTRUN -> [SKIP][30] ([fdo#109271] / [fdo#111827])
[30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk3/igt@[email protected]

* igt@kms_content_protection@dp-mst-lic-type-1:
- shard-iclb: NOTRUN -> [SKIP][31] ([i915#3116])
[31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb7/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][32] ([i915#3116] / [i915#3299])
[32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb7/igt@[email protected]

* igt@kms_cursor_legacy@flip-vs-cursor@atomic-transitions-varying-size:
- shard-glk: [PASS][33] -> [FAIL][34] ([i915#2346])
[33]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk8/igt@kms_cursor_legacy@[email protected]
[34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk1/igt@kms_cursor_legacy@[email protected]

* igt@kms_flip@2x-flip-vs-wf_vblank-interruptible:
- shard-iclb: NOTRUN -> [SKIP][35] ([fdo#109274])
[35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb3/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible.html
- shard-tglb: NOTRUN -> [SKIP][36] ([fdo#109274] / [fdo#111825] / [i915#3637]) +1 similar issue
[36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb6/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible.html

* igt@kms_flip@flip-vs-expired-vblank-interruptible@a-hdmi-a1:
- shard-glk: [PASS][37] -> [FAIL][38] ([i915#79]) +2 similar issues
[37]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk1/igt@kms_flip@[email protected]
[38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk3/igt@kms_flip@[email protected]

* igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling@pipe-a-valid-mode:
- shard-iclb: NOTRUN -> [SKIP][39] ([i915#2672]) +3 similar issues
[39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb5/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling@pipe-a-valid-mode.html

* igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling@pipe-a-default-mode:
- shard-iclb: NOTRUN -> [SKIP][40] ([i915#3555]) +1 similar issue
[40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb2/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-downscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-downscaling@pipe-a-default-mode:
- shard-iclb: [PASS][41] -> [SKIP][42] ([i915#3555])
[41]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb3/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-downscaling@pipe-a-default-mode.html
[42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb2/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-downscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling@pipe-a-valid-mode:
- shard-iclb: NOTRUN -> [SKIP][43] ([i915#2672] / [i915#3555]) +1 similar issue
[43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb7/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling@pipe-a-valid-mode.html

* igt@kms_frontbuffer_tracking@fbc-tiling-4:
- shard-tglb: NOTRUN -> [SKIP][44] ([i915#5439])
[44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb3/igt@[email protected]
- shard-iclb: NOTRUN -> [SKIP][45] ([i915#5438])
[45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb7/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcpsr-1p-offscren-pri-shrfb-draw-render:
- shard-tglb: NOTRUN -> [SKIP][46] ([i915#6497]) +1 similar issue
[46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb1/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscren-pri-shrfb-draw-render.html

* igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-spr-indfb-onoff:
- shard-glk: NOTRUN -> [SKIP][47] ([fdo#109271]) +7 similar issues
[47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk3/igt@[email protected]

* igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-plflip-blt:
- shard-snb: NOTRUN -> [SKIP][48] ([fdo#109271]) +8 similar issues
[48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-snb5/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][49] ([fdo#109280] / [fdo#111825]) +6 similar issues
[49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb7/igt@[email protected]
- shard-iclb: NOTRUN -> [SKIP][50] ([fdo#109280])
[50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb3/igt@[email protected]

* igt@kms_plane_alpha_blend@pipe-c-constant-alpha-max:
- shard-apl: NOTRUN -> [FAIL][51] ([fdo#108145] / [i915#265])
[51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl4/igt@[email protected]

* igt@kms_plane_scaling@plane-scaler-with-pixel-format-unity-scaling@pipe-b-hdmi-a-2:
- shard-glk: [PASS][52] -> [DMESG-WARN][53] ([i915#118])
[52]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk9/igt@kms_plane_scaling@plane-scaler-with-pixel-format-unity-scaling@pipe-b-hdmi-a-2.html
[53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk1/igt@kms_plane_scaling@plane-scaler-with-pixel-format-unity-scaling@pipe-b-hdmi-a-2.html

* igt@kms_plane_scaling@planes-downscale-factor-0-5@pipe-a-edp-1:
- shard-iclb: [PASS][54] -> [SKIP][55] ([i915#5235]) +2 similar issues
[54]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb8/igt@kms_plane_scaling@[email protected]
[55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb2/igt@kms_plane_scaling@[email protected]

* igt@kms_psr2_sf@overlay-plane-move-continuous-sf:
- shard-apl: NOTRUN -> [SKIP][56] ([fdo#109271] / [i915#658])
[56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl4/igt@[email protected]

* igt@kms_psr2_sf@overlay-plane-update-sf-dmg-area:
- shard-tglb: NOTRUN -> [SKIP][57] ([i915#2920])
[57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb2/igt@[email protected]

* igt@kms_vrr@flip-basic:
- shard-tglb: NOTRUN -> [SKIP][58] ([i915#3555])
[58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb1/igt@[email protected]

* igt@nouveau_crc@pipe-b-ctx-flip-detection:
- shard-tglb: NOTRUN -> [SKIP][59] ([i915#2530])
[59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb7/igt@[email protected]

* igt@perf@stress-open-close:
- shard-glk: [PASS][60] -> [INCOMPLETE][61] ([i915#5213])
[60]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk3/igt@[email protected]
[61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk3/igt@[email protected]

* igt@prime_nv_test@nv_write_i915_gtt_mmap_read:
- shard-iclb: NOTRUN -> [SKIP][62] ([fdo#109291])
[62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb8/igt@prime_nv_test@nv_write_i915_gtt_mmap_read.html
- shard-tglb: NOTRUN -> [SKIP][63] ([fdo#109291])
[63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb1/igt@prime_nv_test@nv_write_i915_gtt_mmap_read.html

#### Possible fixes ####

* igt@api_intel_bb@object-reloc-purge-cache:
- {shard-rkl}: [SKIP][64] ([i915#3281]) -> [PASS][65]
[64]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-rkl-2/igt@[email protected]
[65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-rkl-5/igt@[email protected]

* igt@gem_eio@unwedge-stress:
- shard-iclb: [TIMEOUT][66] ([i915#3070]) -> [PASS][67]
[66]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb3/igt@[email protected]
[67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb1/igt@[email protected]
- {shard-rkl}: [TIMEOUT][68] ([i915#3063]) -> [PASS][69]
[68]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-rkl-2/igt@[email protected]
[69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-rkl-5/igt@[email protected]

* igt@gem_exec_balancer@parallel-contexts:
- shard-iclb: [SKIP][70] ([i915#4525]) -> [PASS][71] +2 similar issues
[70]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb3/igt@[email protected]
[71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb4/igt@[email protected]

* igt@gem_exec_endless@dispatch@vecs0:
- shard-tglb: [INCOMPLETE][72] ([i915#3778]) -> [PASS][73]
[72]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb7/igt@gem_exec_endless@[email protected]
[73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb2/igt@gem_exec_endless@[email protected]

* igt@gem_exec_fair@basic-pace-share@rcs0:
- shard-tglb: [FAIL][74] ([i915#2842]) -> [PASS][75]
[74]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb3/igt@gem_exec_fair@[email protected]
[75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb6/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-pace-solo@rcs0:
- shard-apl: [FAIL][76] ([i915#2842]) -> [PASS][77]
[76]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl1/igt@gem_exec_fair@[email protected]
[77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl1/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-throttle@rcs0:
- shard-iclb: [FAIL][78] ([i915#2842]) -> [PASS][79]
[78]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb6/igt@gem_exec_fair@[email protected]
[79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb7/igt@gem_exec_fair@[email protected]

* igt@gem_huc_copy@huc-copy:
- shard-tglb: [SKIP][80] ([i915#2190]) -> [PASS][81]
[80]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb6/igt@[email protected]
[81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb2/igt@[email protected]

* igt@i915_selftest@live@execlists:
- shard-apl: [INCOMPLETE][82] ([i915#6443]) -> [PASS][83]
[82]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl4/igt@i915_selftest@[email protected]
[83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl6/igt@i915_selftest@[email protected]

* igt@kms_flip@dpms-off-confusion@c-edp1:
- shard-tglb: [INCOMPLETE][84] -> [PASS][85]
[84]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-tglb6/igt@kms_flip@[email protected]
[85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-tglb5/igt@kms_flip@[email protected]

* igt@kms_plane_scaling@plane-downscale-with-pixel-format-factor-0-5@pipe-b-edp-1:
- shard-iclb: [SKIP][86] ([i915#5176]) -> [PASS][87] +2 similar issues
[86]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb2/igt@kms_plane_scaling@[email protected]
[87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb4/igt@kms_plane_scaling@[email protected]

* igt@kms_psr@psr2_cursor_plane_onoff:
- shard-iclb: [SKIP][88] ([fdo#109441]) -> [PASS][89]
[88]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb3/igt@kms_psr@psr2_cursor_plane_onoff.html
[89]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb2/igt@kms_psr@psr2_cursor_plane_onoff.html

* igt@perf_pmu@rc6-suspend:
- shard-apl: [DMESG-WARN][90] ([i915#180]) -> [PASS][91] +2 similar issues
[90]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl2/igt@[email protected]
[91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl6/igt@[email protected]

#### Warnings ####

* igt@gem_exec_balancer@parallel-ordering:
- shard-iclb: [FAIL][92] ([i915#6117]) -> [SKIP][93] ([i915#4525])
[92]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb1/igt@[email protected]
[93]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb8/igt@[email protected]

* igt@gem_softpin@evict-single-offset:
- shard-glk: [FAIL][94] ([i915#1888] / [i915#4171]) -> [FAIL][95] ([i915#4171])
[94]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-glk2/igt@[email protected]
[95]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-glk2/igt@[email protected]

* igt@i915_pm_rc6_residency@rc6-idle@rcs0:
- shard-iclb: [WARN][96] ([i915#2684]) -> [FAIL][97] ([i915#2684])
[96]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb2/igt@i915_pm_rc6_residency@[email protected]
[97]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb3/igt@i915_pm_rc6_residency@[email protected]

* igt@kms_psr2_sf@overlay-plane-update-sf-dmg-area:
- shard-iclb: [SKIP][98] ([i915#2920]) -> [SKIP][99] ([fdo#111068] / [i915#658])
[98]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-iclb2/igt@[email protected]
[99]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-iclb1/igt@[email protected]

* igt@runner@aborted:
- shard-apl: ([FAIL][100], [FAIL][101], [FAIL][102], [FAIL][103], [FAIL][104], [FAIL][105]) ([fdo#109271] / [i915#180] / [i915#3002] / [i915#4312] / [i915#5257] / [i915#6599]) -> ([FAIL][106], [FAIL][107], [FAIL][108]) ([i915#180] / [i915#3002] / [i915#4312] / [i915#5257] / [i915#6599])
[100]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl1/igt@[email protected]
[101]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl8/igt@[email protected]
[102]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl3/igt@[email protected]
[103]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl4/igt@[email protected]
[104]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl2/igt@[email protected]
[105]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12094/shard-apl7/igt@[email protected]
[106]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl2/igt@[email protected]
[107]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl7/igt@[email protected]
[108]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/shard-apl7/igt@[email protected]

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

[fdo#103375]: https://bugs.freedesktop.org/show_bug.cgi?id=103375
[fdo#108145]: https://bugs.freedesktop.org/show_bug.cgi?id=108145
[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[fdo#109274]: https://bugs.freedesktop.org/show_bug.cgi?id=109274
[fdo#109278]: https://bugs.freedesktop.org/show_bug.cgi?id=109278
[fdo#109279]: https://bugs.freedesktop.org/show_bug.cgi?id=109279
[fdo#109280]: https://bugs.freedesktop.org/show_bug.cgi?id=109280
[fdo#109283]: https://bugs.freedesktop.org/show_bug.cgi?id=109283
[fdo#109284]: https://bugs.freedesktop.org/show_bug.cgi?id=109284
[fdo#109285]: https://bugs.freedesktop.org/show_bug.cgi?id=109285
[fdo#109289]: https://bugs.freedesktop.org/show_bug.cgi?id=109289
[fdo#109291]: https://bugs.freedesktop.org/show_bug.cgi?id=109291
[fdo#109295]: https://bugs.freedesktop.org/show_bug.cgi?id=109295
[fdo#109302]: https://bugs.freedesktop.org/show_bug.cgi?id=109302
[fdo#109307]: https://bugs.freedesktop.org/show_bug.cgi?id=109307
[fdo#109308]: https://bugs.freedesktop.org/show_bug.cgi?id=109308
[fdo#109313]: https://bugs.freedesktop.org/show_bug.cgi?id=109313
[fdo#109314]: https://bugs.freedesktop.org/show_bug.cgi?id=109314
[fdo#109441]: https://bugs.freedesktop.org/show_bug.cgi?id=109441
[fdo#109506]: https://bugs.freedesktop.org/show_bug.cgi?id=109506
[fdo#109642]: https://bugs.freedesktop.org/show_bug.cgi?id=109642
[fdo#110189]: https://bugs.freedesktop.org/show_bug.cgi?id=110189
[fdo#110542]: https://bugs.freedesktop.org/show_bug.cgi?id=110542
[fdo#110723]: https://bugs.freedesktop.org/show_bug.cgi?id=110723
[fdo#111068]: https://bugs.freedesktop.org/show_bug.cgi?id=111068
[fdo#111614]: https://bugs.freedesktop.org/show_bug.cgi?id=111614
[fdo#111615]: https://bugs.freedesktop.org/show_bug.cgi?id=111615
[fdo#111644]: https://bugs.freedesktop.org/show_bug.cgi?id=111644
[fdo#111656]: https://bugs.freedesktop.org/show_bug.cgi?id=111656
[fdo#111825]: https://bugs.freedesktop.org/show_bug.cgi?id=111825
[fdo#111827]: https://bugs.freedesktop.org/show_bug.cgi?id=111827
[fdo#112054]: https://bugs.freedesktop.org/show_bug.cgi?id=112054
[fdo#112283]: https://bugs.freedesktop.org/show_bug.cgi?id=112283
[i915#1063]: https://gitlab.freedesktop.org/drm/intel/issues/1063
[i915#1072]: https://gitlab.freedesktop.org/drm/intel/issues/1072
[i915#1099]: https://gitlab.freedesktop.org/drm/intel/issues/1099
[i915#1155]: https://gitlab.freedesktop.org/drm/intel/issues/1155
[i915#118]: https://gitlab.freedesktop.org/drm/intel/issues/118
[i915#132]: https://gitlab.freedesktop.org/drm/intel/issues/132
[i915#1397]: https://gitlab.freedesktop.org/drm/intel/issues/1397
[i915#1722]: https://gitlab.freedesktop.org/drm/intel/issues/1722
[i915#180]: https://gitlab.freedesktop.org/drm/intel/issues/180
[i915#1825]: https://gitlab.freedesktop.org/drm/intel/issues/1825
[i915#1839]: https://gitlab.freedesktop.org/drm/intel/issues/1839
[i915#1845]: https://gitlab.freedesktop.org/drm/intel/issues/1845
[i915#1849]: https://gitlab.freedesktop.org/drm/intel/issues/1849
[i915#1888]: https://gitlab.freedesktop.org/drm/intel/issues/1888
[i915#1902]: https://gitlab.freedesktop.org/drm/intel/issues/1902
[i915#1911]: https://gitlab.freedesktop.org/drm/intel/issues/1911
[i915#2190]: https://gitlab.freedesktop.org/drm/intel/issues/2190
[i915#2346]: https://gitlab.freedesktop.org/drm/intel/issues/2346
[i915#2433]: https://gitlab.freedesktop.org/drm/intel/issues/2433
[i915#2436]: https://gitlab.freedesktop.org/drm/intel/issues/2436
[i915#2437]: https://gitlab.freedesktop.org/drm/intel/issues/2437
[i915#2527]: https://gitlab.freedesktop.org/drm/intel/issues/2527
[i915#2530]: https://gitlab.freedesktop.org/drm/intel/issues/2530
[i915#2532]: https://gitlab.freedesktop.org/drm/intel/issues/2532
[i915#2582]: https://gitlab.freedesktop.org/drm/intel/issues/2582
[i915#265]: https://gitlab.freedesktop.org/drm/intel/issues/265
[i915#2658]: https://gitlab.freedesktop.org/drm/intel/issues/2658
[i915#2672]: https://gitlab.freedesktop.org/drm/intel/issues/2672
[i915#2681]: https://gitlab.freedesktop.org/drm/intel/issues/2681
[i915#2684]: https://gitlab.freedesktop.org/drm/intel/issues/2684
[i915#2705]: https://gitlab.freedesktop.org/drm/intel/issues/2705
[i915#280]: https://gitlab.freedesktop.org/drm/intel/issues/280
[i915#284]: https://gitlab.freedesktop.org/drm/intel/issues/284
[i915#2842]: https://gitlab.freedesktop.org/drm/intel/issues/2842
[i915#2846]: https://gitlab.freedesktop.org/drm/intel/issues/2846
[i915#2856]: https://gitlab.freedesktop.org/drm/intel/issues/2856
[i915#2920]: https://gitlab.freedesktop.org/drm/intel/issues/2920
[i915#2994]: https://gitlab.freedesktop.org/drm/intel/issues/2994
[i915#3002]: https://gitlab.freedesktop.org/drm/intel/issues/3002
[i915#3012]: https://gitlab.freedesktop.org/drm/intel/issues/3012
[i915#3063]: https://gitlab.freedesktop.org/drm/intel/issues/3063
[i915#3070]: https://gitlab.freedesktop.org/drm/intel/issues/3070
[i915#3116]: https://gitlab.freedesktop.org/drm/intel/issues/3116
[i915#3281]: https://gitlab.freedesktop.org/drm/intel/issues/3281
[i915#3282]: https://gitlab.freedesktop.org/drm/intel/issues/3282
[i915#3291]: https://gitlab.freedesktop.org/drm/intel/issues/3291
[i915#3297]: https://gitlab.freedesktop.org/drm/intel/issues/3297
[i915#3299]: https://gitlab.freedesktop.org/drm/intel/issues/3299
[i915#3301]: https://gitlab.freedesktop.org/drm/intel/issues/3301
[i915#3318]: https://gitlab.freedesktop.org/drm/intel/issues/3318
[i915#3323]: https://gitlab.freedesktop.org/drm/intel/issues/3323
[i915#3359]: https://gitlab.freedesktop.org/drm/intel/issues/3359
[i915#3376]: https://gitlab.freedesktop.org/drm/intel/issues/3376
[i915#3528]: https://gitlab.freedesktop.org/drm/intel/issues/3528
[i915#3546]: https://gitlab.freedesktop.org/drm/intel/issues/3546
[i915#3555]: https://gitlab.freedesktop.org/drm/intel/issues/3555
[i915#3558]: https://gitlab.freedesktop.org/drm/intel/issues/3558
[i915#3637]: https://gitlab.freedesktop.org/drm/intel/issues/3637
[i915#3638]: https://gitlab.freedesktop.org/drm/intel/issues/3638
[i915#3689]: https://gitlab.freedesktop.org/drm/intel/issues/3689
[i915#3708]: https://gitlab.freedesktop.org/drm/intel/issues/3708
[i915#3734]: https://gitlab.freedesktop.org/drm/intel/issues/3734
[i915#3742]: https://gitlab.freedesktop.org/drm/intel/issues/3742
[i915#3778]: https://gitlab.freedesktop.org/drm/intel/issues/3778
[i915#3804]: https://gitlab.freedesktop.org/drm/intel/issues/3804
[i915#3826]: https://gitlab.freedesktop.org/drm/intel/issues/3826
[i915#3886]: https://gitlab.freedesktop.org/drm/intel/issues/3886
[i915#3955]: https://gitlab.freedesktop.org/drm/intel/issues/3955
[i915#3966]: https://gitlab.freedesktop.org/drm/intel/issues/3966
[i915#3989]: https://gitlab.freedesktop.org/drm/intel/issues/3989
[i915#4016]: https://gitlab.freedesktop.org/drm/intel/issues/4016
[i915#404]: https://gitlab.freedesktop.org/drm/intel/issues/404
[i915#4070]: https://gitlab.freedesktop.org/drm/intel/issues/4070
[i915#4098]: https://gitlab.freedesktop.org/drm/intel/issues/4098
[i915#4103]: https://gitlab.freedesktop.org/drm/intel/issues/4103
[i915#4171]: https://gitlab.freedesktop.org/drm/intel/issues/4171
[i915#426]: https://gitlab.freedesktop.org/drm/intel/issues/426
[i915#4270]: https://gitlab.freedesktop.org/drm/intel/issues/4270
[i915#4281]: https://gitlab.freedesktop.org/drm/intel/issues/4281
[i915#4312]: https://gitlab.freedesktop.org/drm/intel/issues/4312
[i915#4387]: https://gitlab.freedesktop.org/drm/intel/issues/4387
[i915#4525]: https://gitlab.freedesktop.org/drm/intel/issues/4525
[i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
[i915#4941]: https://gitlab.freedesktop.org/drm/intel/issues/4941
[i915#4991]: https://gitlab.freedesktop.org/drm/intel/issues/4991
[i915#5176]: https://gitlab.freedesktop.org/drm/intel/issues/5176
[i915#5182]: https://gitlab.freedesktop.org/drm/intel/issues/5182
[i915#5213]: https://gitlab.freedesktop.org/drm/intel/issues/5213
[i915#5235]: https://gitlab.freedesktop.org/drm/intel/issues/5235
[i915#5257]: https://gitlab.freedesktop.org/drm/intel/issues/5257
[i915#5286]: https://gitlab.freedesktop.org/drm/intel/issues/5286
[i915#5288]: https://gitlab.freedesktop.org/drm/intel/issues/5288
[i915#5289]: https://gitlab.freedesktop.org/drm/intel/issues/5289
[i915#5325]: https://gitlab.freedesktop.org/drm/intel/issues/5325
[i915#5327]: https://gitlab.freedesktop.org/drm/intel/issues/5327
[i915#533]: https://gitlab.freedesktop.org/drm/intel/issues/533
[i915#5438]: https://gitlab.freedesktop.org/drm/intel/issues/5438
[i915#5439]: https://gitlab.freedesktop.org/drm/intel/issues/5439
[i915#5461]: https://gitlab.freedesktop.org/drm/intel/issues/5461
[i915#5566]: https://gitlab.freedesktop.org/drm/intel/issues/5566
[i915#5639]: https://gitlab.freedesktop.org/drm/intel/issues/5639
[i915#5784]: https://gitlab.freedesktop.org/drm/intel/issues/5784
[i915#5982]: https://gitlab.freedesktop.org/drm/intel/issues/5982
[i915#6095]: https://gitlab.freedesktop.org/drm/intel/issues/6095
[i915#6117]: https://gitlab.freedesktop.org/drm/intel/issues/6117
[i915#6227]: https://gitlab.freedesktop.org/drm/intel/issues/6227
[i915#6230]: https://gitlab.freedesktop.org/drm/intel/issues/6230
[i915#6247]: https://gitlab.freedesktop.org/drm/intel/issues/6247
[i915#6248]: https://gitlab.freedesktop.org/drm/intel/issues/6248
[i915#6259]: https://gitlab.freedesktop.org/drm/intel/issues/6259
[i915#6301]: https://gitlab.freedesktop.org/drm/intel/issues/6301
[i915#6335]: https://gitlab.freedesktop.org/drm/intel/issues/6335
[i915#6344]: https://gitlab.freedesktop.org/drm/intel/issues/6344
[i915#6412]: https://gitlab.freedesktop.org/drm/intel/issues/6412
[i915#6433]: https://gitlab.freedesktop.org/drm/intel/issues/6433
[i915#6443]: https://gitlab.freedesktop.org/drm/intel/issues/6443
[i915#6497]: https://gitlab.freedesktop.org/drm/intel/issues/6497
[i915#6524]: https://gitlab.freedesktop.org/drm/intel/issues/6524
[i915#658]: https://gitlab.freedesktop.org/drm/intel/issues/658
[i915#6590]: https://gitlab.freedesktop.org/drm/intel/issues/6590
[i915#6599]: https://gitlab.freedesktop.org/drm/intel/issues/6599
[i915#716]: https://gitlab.freedesktop.org/drm/intel/issues/716
[i915#79]: https://gitlab.freedesktop.org/drm/intel/issues/79

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

* CI: CI-20190529 -> None
* IGT: IGT_6648 -> IGTPW_7756
* Piglit: piglit_4509 -> None

CI-20190529: 20190529
CI_DRM_12094: 2c2f1d1ab12efd051cffcd740978476c96c26d0d @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_7756: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_7756/index.html
IGT_6648: 3c9079c0b97445fbfc903b9c5a1d69707b80af80 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit

== Logs ==

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