Re: [igt-dev] [PATCH i-g-t v8] tests/kms_atomic_transition:reduce execution time

["Gupta, Nidhi1" <nidhi1.gupta@intel.com>]

Hi Lakshmi,

This failure is not related to my patch.
Can we re run this please.

IGT changes
Possible regressions
igt@gem_spin_batch@spin-each:
shard-hsw: PASS -> FAIL

Thanks and Regards
Nidhi Gupta
-----Original Message-----
From: Nidhi Gupta <nidhi1.gupta@intel.com> 
Sent: Thursday, January 28, 2021 6:06 PM
To: igt-dev@lists.freedesktop.org
Cc: B S, Karthik <karthik.b.s@intel.com>; Gupta, Nidhi1 <nidhi1.gupta@intel.com>; Shankar, Uma <uma.shankar@intel.com>
Subject: [PATCH i-g-t v8] tests/kms_atomic_transition:reduce execution time

kms_atomic_transition test is taking minimum of 69.5s time to execute on CI. To reduce the execution time this patch will add the change which will run the test on 1 HDR plane, 1 SDR UV plane, 1 SDR Y plane and skip the rest of the planes.

v4: -restricted execution of all the subtests to
    2 pipes. (Uma)
    -Modified skip_plane() function. (Uma)

v5: -added a extended flag, if it is set by the user
    test will be executed on all the pipes otherwise will be
    executed only on 2 pipes. (Karthik)

v6: -in previous version extended flag and display passed in
     separate structures now added a data_t structure which includes
     igt_display_t, extended flag and drm_fd in single structure. (Uma)

v7: -Added a pipe count variable instead of directly having a check
     of (pipe >= 2). This will be required if platforms are having 2 pipes
     as A+C. (Karthik)

Signed-off-by: Nidhi Gupta <nidhi1.gupta@intel.com>
Reviewed-by: Uma Shankar <uma.shankar@intel.com>
Acked-by: Karthik B S <karthik.b.s@intel.com>
---
 tests/kms_atomic_transition.c | 416 +++++++++++++++++++++-------------
 1 file changed, 257 insertions(+), 159 deletions(-)

diff --git a/tests/kms_atomic_transition.c b/tests/kms_atomic_transition.c index 02206f0a..c3601ae9 100644
--- a/tests/kms_atomic_transition.c
+++ b/tests/kms_atomic_transition.c
@@ -45,13 +45,19 @@ struct plane_parms {
 	uint32_t width, height, mask;
 };
 
+typedef struct {
+	int drm_fd;
+	igt_display_t display;
+	bool extended;
+} data_t;
+
 /* globals for fence support */
 int *timeline;
 pthread_t *thread;
 int *seqno;
 
 static void
-run_primary_test(igt_display_t *display, enum pipe pipe, igt_output_t *output)
+run_primary_test(data_t *data, enum pipe pipe, igt_output_t *output)
 {
 	drmModeModeInfo *mode;
 	igt_plane_t *primary;
@@ -65,34 +71,34 @@ run_primary_test(igt_display_t *display, enum pipe pipe, igt_output_t *output)
 	mode = igt_output_get_mode(output);
 
 	igt_plane_set_fb(primary, NULL);
-	ret = igt_display_try_commit_atomic(display, flags, NULL);
+	ret = igt_display_try_commit_atomic(&data->display, flags, NULL);
 	igt_skip_on_f(ret == -EINVAL, "Primary plane cannot be disabled separately from output\n");
 
-	igt_create_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+	igt_create_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
 		      DRM_FORMAT_XRGB8888, LOCAL_DRM_FORMAT_MOD_NONE, &fb);
 
 	igt_plane_set_fb(primary, &fb);
 
 	for (i = 0; i < 4; i++) {
-		igt_display_commit2(display, COMMIT_ATOMIC);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
 		if (!(i & 1))
-			igt_wait_for_vblank(display->drm_fd,
-					display->pipes[pipe].crtc_offset);
+			igt_wait_for_vblank(data->drm_fd,
+					data->display.pipes[pipe].crtc_offset);
 
 		igt_plane_set_fb(primary, (i & 1) ? &fb : NULL);
-		igt_display_commit2(display, COMMIT_ATOMIC);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
 		if (i & 1)
-			igt_wait_for_vblank(display->drm_fd,
-					display->pipes[pipe].crtc_offset);
+			igt_wait_for_vblank(data->drm_fd,
+					data->display.pipes[pipe].crtc_offset);
 
 		igt_plane_set_fb(primary, (i & 1) ? NULL : &fb);
 	}
 
 	igt_plane_set_fb(primary, NULL);
 	igt_output_set_pipe(output, PIPE_NONE);
-	igt_remove_fb(display->drm_fd, &fb);
+	igt_remove_fb(data->drm_fd, &fb);
 }
 
 static void *fence_inc_thread(void *arg) @@ -120,8 +126,35 @@ static void configure_fencing(igt_plane_t *plane)
 	igt_assert_eq(ret, 0);
 }
 
+static bool skip_plane(data_t *data, igt_plane_t *plane) {
+	int index = plane->index;
+
+	if (data->extended)
+		return false;
+
+	if (!is_i915_device(data->drm_fd))
+		return false;
+
+	if (plane->type == DRM_PLANE_TYPE_CURSOR)
+		return false;
+
+	if (intel_gen(intel_get_drm_devid(data->drm_fd)) < 11)
+		return false;
+
+	/*
+	 * Test 1 HDR plane, 1 SDR UV plane, 1 SDR Y plane.
+	 *
+	 * Kernel registers planes in the hardware Z order:
+	 * 0,1,2 HDR planes
+	 * 3,4 SDR UV planes
+	 * 5,6 SDR Y planes
+	 */
+	return index != 0 && index != 3 && index != 5; }
+
 static int
-wm_setup_plane(igt_display_t *display, enum pipe pipe,
+wm_setup_plane(data_t *data, enum pipe pipe,
 	       uint32_t mask, struct plane_parms *parms, bool fencing)  {
 	igt_plane_t *plane;
@@ -132,9 +165,12 @@ wm_setup_plane(igt_display_t *display, enum pipe pipe,
 	* because most of the modeset operations must be fast
 	* later on.
 	*/
-	for_each_plane_on_pipe(display, pipe, plane) {
+	for_each_plane_on_pipe(&data->display, pipe, plane) {
 		int i = plane->index;
 
+		if (skip_plane(data, plane))
+			continue;
+
 		if (!mask || !(parms[i].mask & mask)) {
 			if (plane->values[IGT_PLANE_FB_ID]) {
 				igt_plane_set_fb(plane, NULL);
@@ -173,13 +209,13 @@ enum transition_type {
 	TRANSITION_MODESET_DISABLE,
 };
 
-static void set_sprite_wh(igt_display_t *display, enum pipe pipe,
+static void set_sprite_wh(data_t *data, enum pipe pipe,
 			  struct plane_parms *parms, struct igt_fb *sprite_fb,
 			  bool alpha, unsigned w, unsigned h)  {
 	igt_plane_t *plane;
 
-	for_each_plane_on_pipe(display, pipe, plane) {
+	for_each_plane_on_pipe(&data->display, pipe, plane) {
 		int i = plane->index;
 
 		if (plane->type == DRM_PLANE_TYPE_PRIMARY || @@ -193,8 +229,8 @@ static void set_sprite_wh(igt_display_t *display, enum pipe pipe,
 		parms[i].height = h;
 	}
 
-	igt_remove_fb(display->drm_fd, sprite_fb);
-	igt_create_fb(display->drm_fd, w, h,
+	igt_remove_fb(data->drm_fd, sprite_fb);
+	igt_create_fb(data->drm_fd, w, h,
 		      alpha ? DRM_FORMAT_ARGB8888 : DRM_FORMAT_XRGB8888,
 		      LOCAL_DRM_FORMAT_MOD_NONE, sprite_fb);  } @@ -205,7 +241,7 @@ static void set_sprite_wh(igt_display_t *display, enum pipe pipe,  #define is_atomic_check_plane_size_errno(errno) \
 		(errno == -EINVAL)
 
-static void setup_parms(igt_display_t *display, enum pipe pipe,
+static void setup_parms(data_t *data, enum pipe pipe,
 			const drmModeModeInfo *mode,
 			struct igt_fb *primary_fb,
 			struct igt_fb *argb_fb,
@@ -216,20 +252,20 @@ static void setup_parms(igt_display_t *display, enum pipe pipe,
 	uint64_t cursor_width, cursor_height;
 	unsigned sprite_width, sprite_height, prev_w, prev_h;
 	bool max_sprite_width, max_sprite_height, alpha = true;
-	uint32_t n_planes = display->pipes[pipe].n_planes;
+	uint32_t n_planes = data->display.pipes[pipe].n_planes;
 	uint32_t n_overlays = 0, overlays[n_planes];
 	igt_plane_t *plane;
 	uint32_t iter_mask = 3;
 
-	do_or_die(drmGetCap(display->drm_fd, DRM_CAP_CURSOR_WIDTH, &cursor_width));
+	do_or_die(drmGetCap(data->drm_fd, DRM_CAP_CURSOR_WIDTH, 
+&cursor_width));
 	if (cursor_width >= mode->hdisplay)
 		cursor_width = mode->hdisplay;
 
-	do_or_die(drmGetCap(display->drm_fd, DRM_CAP_CURSOR_HEIGHT, &cursor_height));
+	do_or_die(drmGetCap(data->drm_fd, DRM_CAP_CURSOR_HEIGHT, 
+&cursor_height));
 	if (cursor_height >= mode->vdisplay)
 		cursor_height = mode->vdisplay;
 
-	for_each_plane_on_pipe(display, pipe, plane) {
+	for_each_plane_on_pipe(&data->display, pipe, plane) {
 		int i = plane->index;
 
 		if (plane->type == DRM_PLANE_TYPE_PRIMARY) { @@ -272,10 +308,10 @@ static void setup_parms(igt_display_t *display, enum pipe pipe,
 		}
 	}
 
-	igt_create_fb(display->drm_fd, cursor_width, cursor_height,
+	igt_create_fb(data->drm_fd, cursor_width, cursor_height,
 		      DRM_FORMAT_ARGB8888, LOCAL_DRM_FORMAT_MOD_NONE, argb_fb);
 
-	igt_create_fb(display->drm_fd, cursor_width, cursor_height,
+	igt_create_fb(data->drm_fd, cursor_width, cursor_height,
 		      DRM_FORMAT_ARGB8888, LOCAL_DRM_FORMAT_MOD_NONE, sprite_fb);
 
 	*iter_max = iter_mask + 1;
@@ -295,11 +331,11 @@ static void setup_parms(igt_display_t *display, enum pipe pipe,
 	while (!max_sprite_width && !max_sprite_height) {
 		int ret;
 
-		set_sprite_wh(display, pipe, parms, sprite_fb,
+		set_sprite_wh(data, pipe, parms, sprite_fb,
 			      alpha, sprite_width, sprite_height);
 
-		wm_setup_plane(display, pipe, (1 << n_planes) - 1, parms, false);
-		ret = igt_display_try_commit_atomic(display, DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+		wm_setup_plane(data, pipe, (1 << n_planes) - 1, parms, false);
+		ret = igt_display_try_commit_atomic(&data->display, 
+DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
 		igt_assert(!is_atomic_check_failure_errno(ret));
 
 		if (!is_atomic_check_plane_size_errno(ret)) { @@ -327,7 +363,7 @@ static void setup_parms(igt_display_t *display, enum pipe pipe,
 			igt_assert_f(n_planes >= 3, "No planes left to proceed with!");
 			if (n_overlays > 0) {
 				uint32_t plane_to_remove = hars_petruska_f54_1_random_unsafe_max(n_overlays);
-				removed_plane = &display->pipes[pipe].planes[overlays[plane_to_remove]];
+				removed_plane = 
+&data->display.pipes[pipe].planes[overlays[plane_to_remove]];
 				igt_plane_set_fb(removed_plane, NULL);
 				while (plane_to_remove < (n_overlays - 1)) {
 					overlays[plane_to_remove] = overlays[plane_to_remove + 1]; @@ -353,7 +389,7 @@ static void setup_parms(igt_display_t *display, enum pipe pipe,
 			max_sprite_height = true;
 	}
 
-	set_sprite_wh(display, pipe, parms, sprite_fb,
+	set_sprite_wh(data, pipe, parms, sprite_fb,
 			alpha, sprite_width, sprite_height);
 
 	igt_info("Running test on pipe %s with resolution %dx%d and sprite size %dx%d alpha %i\n", @@ -361,14 +397,14 @@ static void setup_parms(igt_display_t *display, enum pipe pipe,
 		 sprite_width, sprite_height, alpha);  }
 
-static void prepare_fencing(igt_display_t *display, enum pipe pipe)
+static void prepare_fencing(data_t *data, enum pipe pipe)
 {
 	igt_plane_t *plane;
 	int n_planes;
 
 	igt_require_sw_sync();
 
-	n_planes = display->pipes[pipe].n_planes;
+	n_planes = data->display.pipes[pipe].n_planes;
 	timeline = calloc(sizeof(*timeline), n_planes);
 	igt_assert_f(timeline != NULL, "Failed to allocate memory for timelines\n");
 	thread = calloc(sizeof(*thread), n_planes); @@ -376,15 +412,15 @@ static void prepare_fencing(igt_display_t *display, enum pipe pipe)
 	seqno = calloc(sizeof(*seqno), n_planes);
 	igt_assert_f(seqno != NULL, "Failed to allocate memory for seqno\n");
 
-	for_each_plane_on_pipe(display, pipe, plane)
+	for_each_plane_on_pipe(&data->display, pipe, plane)
 		timeline[plane->index] = sw_sync_timeline_create();  }
 
-static void unprepare_fencing(igt_display_t *display, enum pipe pipe)
+static void unprepare_fencing(data_t *data, enum pipe pipe)
 {
 	igt_plane_t *plane;
 
-	for_each_plane_on_pipe(display, pipe, plane)
+	for_each_plane_on_pipe(&data->display, pipe, plane)
 		close(timeline[plane->index]);
 
 	free(timeline);
@@ -392,12 +428,12 @@ static void unprepare_fencing(igt_display_t *display, enum pipe pipe)
 	free(seqno);
 }
 
-static void atomic_commit(igt_display_t *display, enum pipe pipe, unsigned int flags, void *data, bool fencing)
+static void atomic_commit(data_t *data_v, enum pipe pipe, unsigned int 
+flags, void *data, bool fencing)
 {
 	if (fencing)
-		igt_pipe_request_out_fence(&display->pipes[pipe]);
+		igt_pipe_request_out_fence(&data_v->display.pipes[pipe]);
 
-	igt_display_commit_atomic(display, flags, data);
+	igt_display_commit_atomic(&data_v->display, flags, data);
 }
 
 static int fd_completed(int fd)
@@ -410,10 +446,10 @@ static int fd_completed(int fd)
 	return ret;
 }
 
-static void wait_for_transition(igt_display_t *display, enum pipe pipe, bool nonblocking, bool fencing)
+static void wait_for_transition(data_t *data, enum pipe pipe, bool 
+nonblocking, bool fencing)
 {
 	if (fencing) {
-		int fence_fd = display->pipes[pipe].out_fence_fd;
+		int fence_fd = data->display.pipes[pipe].out_fence_fd;
 
 		if (!nonblocking)
 			igt_assert(fd_completed(fence_fd));
@@ -421,9 +457,9 @@ static void wait_for_transition(igt_display_t *display, enum pipe pipe, bool non
 		igt_assert(sync_fence_wait(fence_fd, 30000) == 0);
 	} else {
 		if (!nonblocking)
-			igt_assert(fd_completed(display->drm_fd));
+			igt_assert(fd_completed(data->drm_fd));
 
-		drmHandleEvent(display->drm_fd, &drm_events);
+		drmHandleEvent(data->drm_fd, &drm_events);
 	}
 }
 
@@ -437,20 +473,20 @@ static void wait_for_transition(igt_display_t *display, enum pipe pipe, bool non
  * so test this and make sure it works.
  */
 static void
-run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output,
+run_transition_test(data_t *data, enum pipe pipe, igt_output_t *output,
 		enum transition_type type, bool nonblocking, bool fencing)  {
 	struct igt_fb fb, argb_fb, sprite_fb;
 	drmModeModeInfo *mode, override_mode;
 	igt_plane_t *plane;
-	igt_pipe_t *pipe_obj = &display->pipes[pipe];
+	igt_pipe_t *pipe_obj = &data->display.pipes[pipe];
 	uint32_t iter_max, i;
 	struct plane_parms parms[pipe_obj->n_planes];
 	unsigned flags = 0;
 	int ret;
 
 	if (fencing)
-		prepare_fencing(display, pipe);
+		prepare_fencing(data, pipe);
 	else
 		flags |= DRM_MODE_PAGE_FLIP_EVENT;
 
@@ -465,24 +501,24 @@ run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 	/* try to force a modeset */
 	override_mode.flags ^= DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NHSYNC;
 
-	igt_create_fb(display->drm_fd, mode->hdisplay, mode->vdisplay,
+	igt_create_fb(data->drm_fd, mode->hdisplay, mode->vdisplay,
 		      DRM_FORMAT_XRGB8888, LOCAL_DRM_FORMAT_MOD_NONE, &fb);
 
 	igt_output_set_pipe(output, pipe);
 
-	wm_setup_plane(display, pipe, 0, NULL, false);
+	wm_setup_plane(data, pipe, 0, NULL, false);
 
 	if (flags & DRM_MODE_ATOMIC_ALLOW_MODESET) {
 		igt_output_set_pipe(output, PIPE_NONE);
 
-		igt_display_commit2(display, COMMIT_ATOMIC);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
 		igt_output_set_pipe(output, pipe);
 	}
 
-	igt_display_commit2(display, COMMIT_ATOMIC);
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
-	setup_parms(display, pipe, mode, &fb, &argb_fb, &sprite_fb, parms, &iter_max);
+	setup_parms(data, pipe, mode, &fb, &argb_fb, &sprite_fb, parms, 
+&iter_max);
 
 	/*
 	 * In some configurations the tests may not run to completion with all @@ -490,19 +526,19 @@ run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 	 * planes to fix this
 	 */
 	while (1) {
-		wm_setup_plane(display, pipe, iter_max - 1, parms, false);
+		wm_setup_plane(data, pipe, iter_max - 1, parms, false);
 
 		if (fencing)
 			igt_pipe_request_out_fence(pipe_obj);
 
-		ret = igt_display_try_commit_atomic(display, DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+		ret = igt_display_try_commit_atomic(&data->display, 
+DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
 		igt_assert(!is_atomic_check_failure_errno(ret));
 
 		if (!is_atomic_check_plane_size_errno(ret) || pipe_obj->n_planes < 3)
 			break;
 
 		ret = 0;
-		for_each_plane_on_pipe(display, pipe, plane) {
+		for_each_plane_on_pipe(&data->display, pipe, plane) {
 			i = plane->index;
 
 			if (plane->type == DRM_PLANE_TYPE_PRIMARY || @@ -519,33 +555,33 @@ run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 			igt_skip("Cannot run tests without proper size sprite planes\n");
 	}
 
-	igt_display_commit2(display, COMMIT_ATOMIC);
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
 	if (type == TRANSITION_AFTER_FREE) {
 		int fence_fd = -1;
 
-		wm_setup_plane(display, pipe, 0, parms, fencing);
+		wm_setup_plane(data, pipe, 0, parms, fencing);
 
-		atomic_commit(display, pipe, flags, (void *)(unsigned long)0, fencing);
+		atomic_commit(data, pipe, flags, (void *)(unsigned long)0, fencing);
 		if (fencing) {
 			fence_fd = pipe_obj->out_fence_fd;
 			pipe_obj->out_fence_fd = -1;
 		}
 
 		/* force planes to be part of commit */
-		for_each_plane_on_pipe(display, pipe, plane) {
+		for_each_plane_on_pipe(&data->display, pipe, plane) {
 			if (parms[plane->index].mask)
 				igt_plane_set_position(plane, 0, 0);
 		}
 
-		igt_display_commit2(display, COMMIT_ATOMIC);
+		igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
 		if (fence_fd != -1) {
 			igt_assert(fd_completed(fence_fd));
 			close(fence_fd);
 		} else {
-			igt_assert(fd_completed(display->drm_fd));
-			wait_for_transition(display, pipe, false, fencing);
+			igt_assert(fd_completed(data->drm_fd));
+			wait_for_transition(data, pipe, false, fencing);
 		}
 		goto cleanup;
 	}
@@ -560,20 +596,20 @@ run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 
 		igt_output_set_pipe(output, pipe);
 
-		if (!wm_setup_plane(display, pipe, i, parms, fencing))
+		if (!wm_setup_plane(data, pipe, i, parms, fencing))
 			continue;
 
-		atomic_commit(display, pipe, flags, (void *)(unsigned long)i, fencing);
-		wait_for_transition(display, pipe, nonblocking, fencing);
+		atomic_commit(data, pipe, flags, (void *)(unsigned long)i, fencing);
+		wait_for_transition(data, pipe, nonblocking, fencing);
 
 		if (type == TRANSITION_MODESET_DISABLE) {
 			igt_output_set_pipe(output, PIPE_NONE);
 
-			if (!wm_setup_plane(display, pipe, 0, parms, fencing))
+			if (!wm_setup_plane(data, pipe, 0, parms, fencing))
 				continue;
 
-			atomic_commit(display, pipe, flags, (void *) 0UL, fencing);
-			wait_for_transition(display, pipe, nonblocking, fencing);
+			atomic_commit(data, pipe, flags, (void *) 0UL, fencing);
+			wait_for_transition(data, pipe, nonblocking, fencing);
 		} else {
 			uint32_t j;
 
@@ -586,44 +622,44 @@ run_transition_test(igt_display_t *display, enum pipe pipe, igt_output_t *output
 				    n_enable_planes < pipe_obj->n_planes)
 					continue;
 
-				if (!wm_setup_plane(display, pipe, j, parms, fencing))
+				if (!wm_setup_plane(data, pipe, j, parms, fencing))
 					continue;
 
 				if (type >= TRANSITION_MODESET)
 					igt_output_override_mode(output, &override_mode);
 
-				atomic_commit(display, pipe, flags, (void *)(unsigned long) j, fencing);
-				wait_for_transition(display, pipe, nonblocking, fencing);
+				atomic_commit(data, pipe, flags, (void *)(unsigned long) j, fencing);
+				wait_for_transition(data, pipe, nonblocking, fencing);
 
-				if (!wm_setup_plane(display, pipe, i, parms, fencing))
+				if (!wm_setup_plane(data, pipe, i, parms, fencing))
 					continue;
 
 				if (type >= TRANSITION_MODESET)
 					igt_output_override_mode(output, NULL);
 
-				atomic_commit(display, pipe, flags, (void *)(unsigned long) i, fencing);
-				wait_for_transition(display, pipe, nonblocking, fencing);
+				atomic_commit(data, pipe, flags, (void *)(unsigned long) i, fencing);
+				wait_for_transition(data, pipe, nonblocking, fencing);
 			}
 		}
 	}
 
 cleanup:
 	if (fencing)
-		unprepare_fencing(display, pipe);
+		unprepare_fencing(data, pipe);
 
 	igt_output_set_pipe(output, PIPE_NONE);
 
-	for_each_plane_on_pipe(display, pipe, plane)
+	for_each_plane_on_pipe(&data->display, pipe, plane)
 		igt_plane_set_fb(plane, NULL);
 
-	igt_display_commit2(display, COMMIT_ATOMIC);
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
-	igt_remove_fb(display->drm_fd, &fb);
-	igt_remove_fb(display->drm_fd, &argb_fb);
-	igt_remove_fb(display->drm_fd, &sprite_fb);
+	igt_remove_fb(data->drm_fd, &fb);
+	igt_remove_fb(data->drm_fd, &argb_fb);
+	igt_remove_fb(data->drm_fd, &sprite_fb);
 }
 
-static void commit_display(igt_display_t *display, unsigned event_mask, bool nonblocking)
+static void commit_display(data_t *data, unsigned event_mask, bool 
+nonblocking)
 {
 	unsigned flags;
 	int num_events = igt_hweight(event_mask); @@ -633,7 +669,7 @@ static void commit_display(igt_display_t *display, unsigned event_mask, bool non
 	if (nonblocking)
 		flags |= DRM_MODE_ATOMIC_NONBLOCK;
 
-	igt_display_commit_atomic(display, flags, NULL);
+	igt_display_commit_atomic(&data->display, flags, NULL);
 
 	igt_debug("Event mask: %x, waiting for %i events\n", event_mask, num_events);
 
@@ -645,7 +681,7 @@ static void commit_display(igt_display_t *display, unsigned event_mask, bool non
 		struct drm_event_vblank *vblank = (void *)buf;
 
 		igt_set_timeout(3, "Timed out while reading drm_fd\n");
-		ret = read(display->drm_fd, buf, sizeof(buf));
+		ret = read(data->drm_fd, buf, sizeof(buf));
 		igt_reset_timeout();
 		if (ret < 0 && (errno == EINTR || errno == EAGAIN))
 			continue;
@@ -661,23 +697,23 @@ static void commit_display(igt_display_t *display, unsigned event_mask, bool non
 	igt_reset_timeout();
 }
 
-static unsigned set_combinations(igt_display_t *display, unsigned mask, struct igt_fb *fb)
+static unsigned set_combinations(data_t *data, unsigned mask, struct 
+igt_fb *fb)
 {
 	igt_output_t *output;
 	enum pipe pipe;
 	unsigned event_mask = 0;
 	int i;
 
-	for (i = 0; i < display->n_outputs; i++)
-		igt_output_set_pipe(&display->outputs[i], PIPE_NONE);
+	for (i = 0; i < data->display.n_outputs; i++)
+		igt_output_set_pipe(&data->display.outputs[i], PIPE_NONE);
 
-	for_each_pipe(display, pipe) {
-		igt_plane_t *plane = igt_pipe_get_plane_type(&display->pipes[pipe],
+	for_each_pipe(&data->display, pipe) {
+		igt_plane_t *plane = 
+igt_pipe_get_plane_type(&data->display.pipes[pipe],
 			DRM_PLANE_TYPE_PRIMARY);
 		drmModeModeInfo *mode = NULL;
 
 		if (!(mask & (1 << pipe))) {
-			if (igt_pipe_is_prop_changed(display, pipe, IGT_CRTC_ACTIVE)) {
+			if (igt_pipe_is_prop_changed(&data->display, pipe, IGT_CRTC_ACTIVE)) 
+{
 				event_mask |= 1 << pipe;
 				igt_plane_set_fb(plane, NULL);
 			}
@@ -687,7 +723,7 @@ static unsigned set_combinations(igt_display_t *display, unsigned mask, struct i
 
 		event_mask |= 1 << pipe;
 
-		for_each_valid_output_on_pipe(display, pipe, output) {
+		for_each_valid_output_on_pipe(&data->display, pipe, output) {
 			if (output->pending_pipe != PIPE_NONE)
 				continue;
 
@@ -707,16 +743,16 @@ static unsigned set_combinations(igt_display_t *display, unsigned mask, struct i
 	return event_mask;
 }
 
-static void refresh_primaries(igt_display_t *display, int mask)
+static void refresh_primaries(data_t  *data, int mask)
 {
 	enum pipe pipe;
 	igt_plane_t *plane;
 
-	for_each_pipe(display, pipe) {
+	for_each_pipe(&data->display, pipe) {
 		if (!((1 << pipe) & mask))
 			continue;
 
-		for_each_plane_on_pipe(display, pipe, plane)
+		for_each_plane_on_pipe(&data->display, pipe, plane)
 			if (plane->type == DRM_PLANE_TYPE_PRIMARY)
 				igt_plane_set_position(plane, 0, 0);
 	}
@@ -737,7 +773,7 @@ static void collect_crcs_mask(igt_pipe_crc_t **pipe_crcs, unsigned mask, igt_crc
 	}
 }
 
-static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblocking, bool fencing)
+static void run_modeset_tests(data_t *data, int howmany, bool 
+nonblocking, bool fencing)
 {
 	struct igt_fb fbs[2];
 	int i, j = 0;
@@ -746,33 +782,33 @@ static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblock
 	igt_output_t *output;
 	unsigned width = 0, height = 0;
 
-	for (i = 0; i < display->n_outputs; i++)
-		igt_output_set_pipe(&display->outputs[i], PIPE_NONE);
+	for (i = 0; i < data->display.n_outputs; i++)
+		igt_output_set_pipe(&data->display.outputs[i], PIPE_NONE);
 
-	for_each_connected_output(display, output) {
+	for_each_connected_output(&data->display, output) {
 		drmModeModeInfo *mode = igt_output_get_mode(output);
 
 		width = max(width, mode->hdisplay);
 		height = max(height, mode->vdisplay);
 	}
 
-	igt_create_pattern_fb(display->drm_fd, width, height,
+	igt_create_pattern_fb(data->drm_fd, width, height,
 				   DRM_FORMAT_XRGB8888, 0, &fbs[0]);
-	igt_create_color_pattern_fb(display->drm_fd, width, height,
+	igt_create_color_pattern_fb(data->drm_fd, width, height,
 				    DRM_FORMAT_XRGB8888, 0, .5, .5, .5, &fbs[1]);
 
-	for_each_pipe(display, i) {
-		igt_pipe_t *pipe = &display->pipes[i];
+	for_each_pipe(&data->display, i) {
+		igt_pipe_t *pipe = &data->display.pipes[i];
 		igt_plane_t *plane = igt_pipe_get_plane_type(pipe, DRM_PLANE_TYPE_PRIMARY);
 		drmModeModeInfo *mode = NULL;
 
 		/* count enable pipes to set max iteration */
 		j += 1;
 
-		if (is_i915_device(display->drm_fd))
-			pipe_crcs[i] = igt_pipe_crc_new(display->drm_fd, i, INTEL_PIPE_CRC_SOURCE_AUTO);
+		if (is_i915_device(data->drm_fd))
+			pipe_crcs[i] = igt_pipe_crc_new(data->drm_fd, i, 
+INTEL_PIPE_CRC_SOURCE_AUTO);
 
-		for_each_valid_output_on_pipe(display, i, output) {
+		for_each_valid_output_on_pipe(&data->display, i, output) {
 			if (output->pending_pipe != PIPE_NONE)
 				continue;
 
@@ -787,7 +823,7 @@ static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblock
 			igt_plane_set_size(plane, mode->hdisplay, mode->vdisplay);
 
 			if (fencing)
-				igt_pipe_request_out_fence(&display->pipes[i]);
+				igt_pipe_request_out_fence(&data->display.pipes[i]);
 		} else {
 			igt_plane_set_fb(plane, NULL);
 		}
@@ -795,7 +831,7 @@ static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblock
 
 	iter_max = 1 << j;
 
-	igt_display_commit2(display, COMMIT_ATOMIC);
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
 	for (i = 0; i < iter_max; i++) {
 		igt_crc_t crcs[5][IGT_MAX_PIPES];
@@ -804,11 +840,11 @@ static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblock
 		if (igt_hweight(i) > howmany)
 			continue;
 
-		event_mask = set_combinations(display, i, &fbs[0]);
+		event_mask = set_combinations(data, i, &fbs[0]);
 		if (!event_mask && i)
 			continue;
 
-		commit_display(display, event_mask, nonblocking);
+		commit_display(data, event_mask, nonblocking);
 
 		collect_crcs_mask(pipe_crcs, i, crcs[0]);
 
@@ -819,30 +855,30 @@ static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblock
 			if (igt_hweight(i) < howmany && igt_hweight(j) < howmany)
 				continue;
 
-			event_mask = set_combinations(display, j, &fbs[1]);
+			event_mask = set_combinations(data, j, &fbs[1]);
 			if (!event_mask)
 				continue;
 
-			commit_display(display, event_mask, nonblocking);
+			commit_display(data, event_mask, nonblocking);
 
 			collect_crcs_mask(pipe_crcs, j, crcs[1]);
 
-			refresh_primaries(display, j);
-			commit_display(display, j, nonblocking);
+			refresh_primaries(data, j);
+			commit_display(data, j, nonblocking);
 			collect_crcs_mask(pipe_crcs, j, crcs[2]);
 
-			event_mask = set_combinations(display, i, &fbs[0]);
+			event_mask = set_combinations(data, i, &fbs[0]);
 			if (!event_mask)
 				continue;
 
-			commit_display(display, event_mask, nonblocking);
+			commit_display(data, event_mask, nonblocking);
 			collect_crcs_mask(pipe_crcs, i, crcs[3]);
 
-			refresh_primaries(display, i);
-			commit_display(display, i, nonblocking);
+			refresh_primaries(data, i);
+			commit_display(data, i, nonblocking);
 			collect_crcs_mask(pipe_crcs, i, crcs[4]);
 
-			if (!is_i915_device(display->drm_fd))
+			if (!is_i915_device(data->drm_fd))
 				continue;
 
 			for (int k = 0; k < IGT_MAX_PIPES; k++) { @@ -857,28 +893,28 @@ static void run_modeset_tests(igt_display_t *display, int howmany, bool nonblock
 		}
 	}
 
-	set_combinations(display, 0, NULL);
-	igt_display_commit2(display, COMMIT_ATOMIC);
+	set_combinations(data, 0, NULL);
+	igt_display_commit2(&data->display, COMMIT_ATOMIC);
 
-	if (is_i915_device(display->drm_fd)) {
-		for_each_pipe(display, i)
+	if (is_i915_device(data->drm_fd)) {
+		for_each_pipe(&data->display, i)
 			igt_pipe_crc_free(pipe_crcs[i]);
 	}
 
-	igt_remove_fb(display->drm_fd, &fbs[1]);
-	igt_remove_fb(display->drm_fd, &fbs[0]);
+	igt_remove_fb(data->drm_fd, &fbs[1]);
+	igt_remove_fb(data->drm_fd, &fbs[0]);
 }
 
-static void run_modeset_transition(igt_display_t *display, int requested_outputs, bool nonblocking, bool fencing)
+static void run_modeset_transition(data_t *data, int requested_outputs, 
+bool nonblocking, bool fencing)
 {
 	igt_output_t *outputs[IGT_MAX_PIPES] = {};
 	int num_outputs = 0;
 	enum pipe pipe;
 
-	for_each_pipe(display, pipe) {
+	for_each_pipe(&data->display, pipe) {
 		igt_output_t *output;
 
-		for_each_valid_output_on_pipe(display, pipe, output) {
+		for_each_valid_output_on_pipe(&data->display, pipe, output) {
 			int i;
 
 			for (i = pipe - 1; i >= 0; i--)
@@ -897,7 +933,7 @@ static void run_modeset_transition(igt_display_t *display, int requested_outputs
 		      "Should have at least %i outputs, found %i\n",
 		      requested_outputs, num_outputs);
 
-	run_modeset_tests(display, requested_outputs, nonblocking, fencing);
+	run_modeset_tests(data, requested_outputs, nonblocking, fencing);
 }
 
 static bool output_is_internal_panel(igt_output_t *output) @@ -913,70 +949,116 @@ static bool output_is_internal_panel(igt_output_t *output)
 	}
 }
 
-igt_main
+static int opt_handler(int opt, int opt_index, void *_data) {
+	data_t *data = _data;
+
+	switch (opt) {
+	case 'e':
+		data->extended = true;
+		break;
+	}
+
+	return IGT_OPT_HANDLER_SUCCESS;
+}
+
+static const struct option long_opts[] = {
+	{ .name = "extended", .has_arg = false, .val = 'e', },
+	{}
+};
+
+static const char help_str[] =
+	"  --extended\t\tRun the extended tests\n";
+
+static data_t data;
+
+igt_main_args("", long_opts, help_str, opt_handler, &data)
 {
-	igt_display_t display;
 	igt_output_t *output;
 	enum pipe pipe;
 	int i, count = 0;
+	int pipe_count = 0;
 
 	igt_fixture {
-		display.drm_fd = drm_open_driver_master(DRIVER_ANY);
+		data.drm_fd = drm_open_driver_master(DRIVER_ANY);
 
 		kmstest_set_vt_graphics_mode();
 
-		igt_display_require(&display, display.drm_fd);
-		igt_require(display.is_atomic);
+		igt_display_require(&data.display, data.drm_fd);
+		igt_require(&data.display.is_atomic);
 
-		igt_display_require_output(&display);
+		igt_display_require_output(&data.display);
 
-		for_each_connected_output(&display, output)
+		for_each_connected_output(&data.display, output)
 			count++;
 	}
 
 	igt_subtest("plane-primary-toggle-with-vblank-wait")
-		for_each_pipe_with_valid_output(&display, pipe, output)
-			run_primary_test(&display, pipe, output);
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
+			run_primary_test(&data, pipe, output);
+
+		}
 
 	igt_subtest_with_dynamic("plane-all-transition") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_PLANES, false, false);
+				run_transition_test(&data, pipe, output, TRANSITION_PLANES, false, 
+false);
 		}
 	}
 
 	igt_subtest_with_dynamic("plane-all-transition-fencing") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_PLANES, false, true);
+				run_transition_test(&data, pipe, output, TRANSITION_PLANES, false, 
+true);
 		}
 	}
 
 	igt_subtest_with_dynamic("plane-all-transition-nonblocking") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_PLANES, true, false);
+				run_transition_test(&data, pipe, output, TRANSITION_PLANES, true, 
+false);
 		}
 	}
 
 	igt_subtest_with_dynamic("plane-all-transition-nonblocking-fencing") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_PLANES, true, true);
+				run_transition_test(&data, pipe, output, TRANSITION_PLANES, true, 
+true);
 		}
 	}
 
 	igt_subtest_with_dynamic("plane-use-after-nonblocking-unbind") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_AFTER_FREE, true, false);
+				run_transition_test(&data, pipe, output, TRANSITION_AFTER_FREE, 
+true, false);
 		}
 	}
 
 	igt_subtest_with_dynamic("plane-use-after-nonblocking-unbind-fencing") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_AFTER_FREE, true, true);
+				run_transition_test(&data, pipe, output, TRANSITION_AFTER_FREE, 
+true, true);
 		}
 	}
 
@@ -986,76 +1068,92 @@ igt_main
 	 * panels with long power cycle delays.
 	 */
 	igt_subtest_with_dynamic("plane-all-modeset-transition")
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			if (output_is_internal_panel(output))
 				continue;
 
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_MODESET, false, false);
+				run_transition_test(&data, pipe, output, TRANSITION_MODESET, false, 
+false);
 		}
 
 	igt_subtest_with_dynamic("plane-all-modeset-transition-fencing")
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			if (output_is_internal_panel(output))
 				continue;
 
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_MODESET, false, true);
+				run_transition_test(&data, pipe, output, TRANSITION_MODESET, false, 
+true);
 		}
 
 	igt_subtest_with_dynamic("plane-all-modeset-transition-internal-panels") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			if (!output_is_internal_panel(output))
 				continue;
 
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_MODESET_FAST, false, false);
+				run_transition_test(&data, pipe, output, TRANSITION_MODESET_FAST, 
+false, false);
 		}
 	}
 
 	igt_subtest_with_dynamic("plane-all-modeset-transition-fencing-internal-panels") {
-		for_each_pipe_with_valid_output(&display, pipe, output) {
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
 			if (!output_is_internal_panel(output))
 				continue;
 
 			igt_dynamic_f("%s-pipe-%s", igt_output_name(output), kmstest_pipe_name(pipe))
-				run_transition_test(&display, pipe, output, TRANSITION_MODESET_FAST, false, true);
+				run_transition_test(&data, pipe, output, TRANSITION_MODESET_FAST, 
+false, true);
 		}
 	}
 
 	igt_subtest("plane-toggle-modeset-transition")
-		for_each_pipe_with_valid_output(&display, pipe, output)
-			run_transition_test(&display, pipe, output, TRANSITION_MODESET_DISABLE, false, false);
+		for_each_pipe_with_valid_output(&data.display, pipe, output) {
+			if (pipe_count >= 2 && !data.extended)
+				break;
+			pipe_count++;
+			run_transition_test(&data, pipe, output, TRANSITION_MODESET_DISABLE, false, false);
+		}
 
 	igt_subtest_with_dynamic("modeset-transition") {
 		for (i = 1; i <= count; i++) {
 			igt_dynamic_f("%ix-outputs", i)
-				run_modeset_transition(&display, i, false, false);
+				run_modeset_transition(&data, i, false, false);
 		}
 	}
 
 	igt_subtest_with_dynamic("modeset-transition-nonblocking") {
 		for (i = 1; i <= count; i++) {
 			igt_dynamic_f("%ix-outputs", i)
-				run_modeset_transition(&display, i, true, false);
+				run_modeset_transition(&data, i, true, false);
 		}
 	}
 
 	igt_subtest_with_dynamic("modeset-transition-fencing") {
 		for (i = 1; i <= count; i++) {
 			igt_dynamic_f("%ix-outputs", i)
-				run_modeset_transition(&display, i, false, true);
+				run_modeset_transition(&data, i, false, true);
 		}
 	}
 
 	igt_subtest_with_dynamic("modeset-transition-nonblocking-fencing") {
 		for (i = 1; i <= count; i++) {
 			igt_dynamic_f("%ix-outputs", i)
-				run_modeset_transition(&display, i, true, true);
+				run_modeset_transition(&data, i, true, true);
 		}
 	}
 
 	igt_fixture {
-		igt_display_fini(&display);
+		igt_display_fini(&data.display);
 	}
 }
--
2.26.2

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