Skip to contentSkip to conversation

tests/intel/xe_sriov_scheduling: improve scheduling coverage

PATCH In review Marcin Bernatowicz 4 participants 21 messages May 27 – Jun 9

lore
Share & tools
lore
#0 lore raw

cover tests/intel/xe_sriov_scheduling: improve scheduling coverage

Improve SR-IOV scheduling test coverage by adding default-enabled fair-scheduling validation, broadening equal-throughput and nonpreempt-engine-resets scenarios across GTs and both LOW/NORMAL priorities, and strengthening result confidence with PMU-based checks using engine-active-ticks and engine-total-ticks.

This series also includes earlier preparatory changes: timestamp helper, scheduling priority support, and a const-correct helper signature update.

Marcin Bernatowicz (8):
tests/intel/xe_sriov_scheduling: Use timestamp helper tests/intel/xe_sriov_scheduling: Add scheduling priority support tests/intel/xe_sriov_scheduling: Make sysfs_get_job_timeout_ms take
const eci
tests/intel/xe_sriov_scheduling: Add PMU-based verification helpers tests/intel/xe_sriov_scheduling: Raise min exec quantum to 2ms tests/intel/xe_sriov_scheduling: Refactor throughput_ratio and
nonpreempt-engine-resets test
tests/intel/xe_sriov_scheduling: Remove unused log_sample_values
helper
tests/intel/xe_sriov_scheduling: Add default fair scheduling test

 tests/intel/xe_sriov_scheduling.c | 1035 ++++++++++++++++++++++++-----
 1 file changed, 859 insertions(+), 176 deletions(-)
Signature · 1 line
2.43.0
#1 lore raw

PATCH 1/8 tests/intel/xe_sriov_scheduling: Use timestamp helper

Replace open-coded timestamp collection with current_timestamp_ns().

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)
tests/intel/xe_sriov_scheduling.c +13 -13
index 4228eea2d..509d6fd00 100644
@@ -85,6 +85,15 @@ struct subm_set {
 	pthread_barrier_t barrier;
 };
 
+static uint64_t current_timestamp_ns(void)
+{
+	struct timespec tv;
+
+	igt_gettime(&tv);
+
+	return tv.tv_sec * (uint64_t)NSEC_PER_SEC + (uint64_t)tv.tv_nsec;
+}
+
 static void subm_init(struct subm *s, int fd, int vf_num, uint64_t addr,
 		      struct drm_xe_engine_class_instance hwe,
 		      unsigned int inflight)
@@ -164,8 +173,6 @@ static void subm_wait_slot(struct subm *s, unsigned int slot, uint64_t abs_timeo
 
 static void subm_exec_slot(struct subm *s, unsigned int slot)
 {
-	struct timespec tv;
-
 	syncobj_reset(s->fd, &s->done_fence[slot], 1);
 	memset(&s->sync[0], 0, sizeof(s->sync));
 	s->sync[0].type = DRM_XE_SYNC_TYPE_SYNCOBJ;
@@ -174,8 +181,7 @@ static void subm_exec_slot(struct subm *s, unsigned int slot)
 	s->exec.num_syncs = 1;
 	s->exec.syncs = to_user_pointer(&s->sync[0]);
 	s->exec.address = s->addr[slot];
-	igt_gettime(&tv);
-	s->submit_ts[slot] = (uint64_t)tv.tv_sec * (uint64_t)NSEC_PER_SEC + (uint64_t)tv.tv_nsec;
+	s->submit_ts[slot] = current_timestamp_ns();
 	xe_exec(s->fd, &s->exec);
 }
 
@@ -200,12 +206,9 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
 {
 	const unsigned int inflight = s->slots;
 	unsigned int submitted = 0;
-	struct timespec tv;
 	unsigned int i;
 
-	igt_gettime(&tv);
-	stats->start_timestamp =
-		tv.tv_sec * (uint64_t)NSEC_PER_SEC + tv.tv_nsec;
+	stats->start_timestamp = current_timestamp_ns();
 	igt_debug("[%s] start_timestamp: %f\n", s->id, stats->start_timestamp * 1e-9);
 
 	/* Prefill */
@@ -222,9 +225,7 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
 		unsigned int slot = i % inflight;
 
 		subm_wait_slot(s, slot, INT64_MAX);
-		igt_gettime(&tv);
-		stats->complete_ts[i] = (uint64_t)tv.tv_sec * (uint64_t)NSEC_PER_SEC +
-					(uint64_t)tv.tv_nsec;
+		stats->complete_ts[i] = current_timestamp_ns();
 		igt_stats_push(&stats->samples, stats->complete_ts[i] - s->submit_ts[slot]);
 
 		if (!subm_is_work_complete(s, slot)) {
@@ -246,8 +247,7 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
 		}
 	}
 
-	igt_gettime(&tv);
-	stats->end_timestamp = tv.tv_sec * (uint64_t)NSEC_PER_SEC + tv.tv_nsec;
+	stats->end_timestamp = current_timestamp_ns();
 	igt_debug("[%s] end_timestamp: %f\n", s->id, stats->end_timestamp * 1e-9);
 }
 
Signature · 1 line
2.43.0
#2 lore raw

Re: [PATCH i-g-t 1/8] tests/intel/xe_sriov_scheduling: Use timestamp helper

Hi Marcin,

Quoted 15 lines · Marcin Bernatowicz

Replace open-coded timestamp collection with current_timestamp_ns().

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)
tests/intel/xe_sriov_scheduling.c +0 -0
index 4228eea2d..509d6fd00 100644

tests/intel/xe_sriov_scheduling.c struct subm_set { · line 92

Quoted 8 lines
tests/intel/xe_sriov_scheduling.c +5 -0
@@ -85,6 +85,15 @@ struct subm_set {
 	pthread_barrier_t barrier;
 };
 
+static uint64_t current_timestamp_ns(void)
+{
+	struct timespec tv;
+
+	igt_gettime(&tv);

Looks like a good candidate for a lib function:

uint64_t igt_gettime_ns(void)

Regards,
Kamil

Quoted 64 lines
tests/intel/xe_sriov_scheduling.c +8 -13
+
+	return tv.tv_sec * (uint64_t)NSEC_PER_SEC + (uint64_t)tv.tv_nsec;
+}
+
 static void subm_init(struct subm *s, int fd, int vf_num, uint64_t addr,
 		      struct drm_xe_engine_class_instance hwe,
 		      unsigned int inflight)
@@ -164,8 +173,6 @@ static void subm_wait_slot(struct subm *s, unsigned int slot, uint64_t abs_timeo
 
 static void subm_exec_slot(struct subm *s, unsigned int slot)
 {
-	struct timespec tv;
-
 	syncobj_reset(s->fd, &s->done_fence[slot], 1);
 	memset(&s->sync[0], 0, sizeof(s->sync));
 	s->sync[0].type = DRM_XE_SYNC_TYPE_SYNCOBJ;
@@ -174,8 +181,7 @@ static void subm_exec_slot(struct subm *s, unsigned int slot)
 	s->exec.num_syncs = 1;
 	s->exec.syncs = to_user_pointer(&s->sync[0]);
 	s->exec.address = s->addr[slot];
-	igt_gettime(&tv);
-	s->submit_ts[slot] = (uint64_t)tv.tv_sec * (uint64_t)NSEC_PER_SEC + (uint64_t)tv.tv_nsec;
+	s->submit_ts[slot] = current_timestamp_ns();
 	xe_exec(s->fd, &s->exec);
 }
 
@@ -200,12 +206,9 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
 {
 	const unsigned int inflight = s->slots;
 	unsigned int submitted = 0;
-	struct timespec tv;
 	unsigned int i;
 
-	igt_gettime(&tv);
-	stats->start_timestamp =
-		tv.tv_sec * (uint64_t)NSEC_PER_SEC + tv.tv_nsec;
+	stats->start_timestamp = current_timestamp_ns();
 	igt_debug("[%s] start_timestamp: %f\n", s->id, stats->start_timestamp * 1e-9);
 
 	/* Prefill */
@@ -222,9 +225,7 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
 		unsigned int slot = i % inflight;
 
 		subm_wait_slot(s, slot, INT64_MAX);
-		igt_gettime(&tv);
-		stats->complete_ts[i] = (uint64_t)tv.tv_sec * (uint64_t)NSEC_PER_SEC +
-					(uint64_t)tv.tv_nsec;
+		stats->complete_ts[i] = current_timestamp_ns();
 		igt_stats_push(&stats->samples, stats->complete_ts[i] - s->submit_ts[slot]);
 
 		if (!subm_is_work_complete(s, slot)) {
@@ -246,8 +247,7 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
 		}
 	}
 
-	igt_gettime(&tv);
-	stats->end_timestamp = tv.tv_sec * (uint64_t)NSEC_PER_SEC + tv.tv_nsec;
+	stats->end_timestamp = current_timestamp_ns();
 	igt_debug("[%s] end_timestamp: %f\n", s->id, stats->end_timestamp * 1e-9);
 }
 
Signature · 1 line
2.43.0
Reviewed-by on v1 1/8
#3 lore raw

Re: [PATCH i-g-t 1/8] tests/intel/xe_sriov_scheduling: Use timestamp helper

In reply to Marcin Bernatowicz
Quoted 6 lines · Marcin Bernatowicz

Replace open-coded timestamp collection with current_timestamp_ns().

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 78 lines
---
  tests/intel/xe_sriov_scheduling.c | 26 +++++++++++++-------------
  1 file changed, 13 insertions(+), 13 deletions(-)
tests/intel/xe_sriov_scheduling.c +13 -13
index 4228eea2d..509d6fd00 100644
@@ -85,6 +85,15 @@ struct subm_set {
  	pthread_barrier_t barrier;
  };
 
+static uint64_t current_timestamp_ns(void)
+{
+	struct timespec tv;
+
+	igt_gettime(&tv);
+
+	return tv.tv_sec * (uint64_t)NSEC_PER_SEC + (uint64_t)tv.tv_nsec;
+}
+
  static void subm_init(struct subm *s, int fd, int vf_num, uint64_t addr,
  		      struct drm_xe_engine_class_instance hwe,
  		      unsigned int inflight)
@@ -164,8 +173,6 @@ static void subm_wait_slot(struct subm *s, unsigned int slot, uint64_t abs_timeo
 
  static void subm_exec_slot(struct subm *s, unsigned int slot)
  {
-	struct timespec tv;
-
  	syncobj_reset(s->fd, &s->done_fence[slot], 1);
  	memset(&s->sync[0], 0, sizeof(s->sync));
  	s->sync[0].type = DRM_XE_SYNC_TYPE_SYNCOBJ;
@@ -174,8 +181,7 @@ static void subm_exec_slot(struct subm *s, unsigned int slot)
  	s->exec.num_syncs = 1;
  	s->exec.syncs = to_user_pointer(&s->sync[0]);
  	s->exec.address = s->addr[slot];
-	igt_gettime(&tv);
-	s->submit_ts[slot] = (uint64_t)tv.tv_sec * (uint64_t)NSEC_PER_SEC + (uint64_t)tv.tv_nsec;
+	s->submit_ts[slot] = current_timestamp_ns();
  	xe_exec(s->fd, &s->exec);
  }
 
@@ -200,12 +206,9 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
  {
  	const unsigned int inflight = s->slots;
  	unsigned int submitted = 0;
-	struct timespec tv;
  	unsigned int i;
 
-	igt_gettime(&tv);
-	stats->start_timestamp =
-		tv.tv_sec * (uint64_t)NSEC_PER_SEC + tv.tv_nsec;
+	stats->start_timestamp = current_timestamp_ns();
  	igt_debug("[%s] start_timestamp: %f\n", s->id, stats->start_timestamp * 1e-9);
 
  	/* Prefill */
@@ -222,9 +225,7 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
  		unsigned int slot = i % inflight;
 
  		subm_wait_slot(s, slot, INT64_MAX);
-		igt_gettime(&tv);
-		stats->complete_ts[i] = (uint64_t)tv.tv_sec * (uint64_t)NSEC_PER_SEC +
-					(uint64_t)tv.tv_nsec;
+		stats->complete_ts[i] = current_timestamp_ns();
  		igt_stats_push(&stats->samples, stats->complete_ts[i] - s->submit_ts[slot]);
 
  		if (!subm_is_work_complete(s, slot)) {
@@ -246,8 +247,7 @@ static void subm_exec_loop(struct subm *s, struct subm_stats *stats,
  		}
  	}
 
-	igt_gettime(&tv);
-	stats->end_timestamp = tv.tv_sec * (uint64_t)NSEC_PER_SEC + tv.tv_nsec;
+	stats->end_timestamp = current_timestamp_ns();
  	igt_debug("[%s] end_timestamp: %f\n", s->id, stats->end_timestamp * 1e-9);
  }
 
#4 lore raw

PATCH 2/8 tests/intel/xe_sriov_scheduling: Add scheduling priority support

In reply to Marcin Bernatowicz

Extend vf_sched_params with scheduling priority and program it together with exec quantum and preempt timeout. Also print the selected priority in the test logs.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 31 +++++++++++++++++++++++--------
 1 file changed, 23 insertions(+), 8 deletions(-)
tests/intel/xe_sriov_scheduling.c +23 -8
index 509d6fd00..f4e674fe2 100644
@@ -370,6 +370,7 @@ static void init_vf_ids(uint8_t *array, size_t n,
 struct vf_sched_params {
 	uint32_t exec_quantum_ms;
 	uint32_t preempt_timeout_us;
+	enum xe_sriov_sched_priority priority;
 };
 
 static int __set_vfs_scheduling_params(int pf_fd, int num_vfs,
@@ -389,6 +390,12 @@ static int __set_vfs_scheduling_params(int pf_fd, int num_vfs,
 			  p->preempt_timeout_us, ret))
 		return ret;
 
+	ret = __xe_sriov_admin_bulk_set_sched_priority(pf_fd, p->priority);
+	if (igt_warn_on_f(ret,
+			  "Failed to bulk set sched priority=%d: %d\n",
+			  p->priority, ret))
+		return ret;
+
 	return ret;
 }
 
@@ -607,10 +614,12 @@ static unsigned int select_inflight_k(unsigned int duration_ms,
 static struct vf_sched_params prepare_vf_sched_params(int num_threads,
 						      int min_num_repeats,
 						      int job_timeout_ms,
-						      const struct subm_opts *opts)
+						      const struct subm_opts *opts,
+						      enum xe_sriov_sched_priority priority)
 {
 	struct vf_sched_params params = { MIN_EXEC_QUANTUM_MS,
-					  derive_preempt_timeout_us(MIN_EXEC_QUANTUM_MS) };
+					  derive_preempt_timeout_us(MIN_EXEC_QUANTUM_MS),
+						  priority };
 
 	if (opts->exec_quantum_ms || opts->preempt_timeout_us) {
 		if (opts->exec_quantum_ms)
@@ -638,12 +647,13 @@ static struct vf_sched_params prepare_vf_sched_params(int num_threads,
 }
 
 static struct job_sched_params
-prepare_job_sched_params(int num_threads, int job_timeout_ms, const struct subm_opts *opts)
+prepare_job_sched_params(int num_threads, int job_timeout_ms, const struct subm_opts *opts,
+			 enum xe_sriov_sched_priority priority)
 {
 	struct job_sched_params params = { };
 
 	params.sched_params = prepare_vf_sched_params(num_threads, MIN_NUM_REPEATS,
-						      job_timeout_ms, opts);
+							      job_timeout_ms, opts, priority);
 	params.duration_ms = calculate_job_duration_ms(params.sched_params.exec_quantum_ms);
 	params.num_repeats = adjust_num_repeats(params.duration_ms, num_threads);
 
@@ -663,13 +673,15 @@ static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opt
 	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
 	struct job_sched_params job_sched_params = prepare_job_sched_params(num_vfs + 1,
 									    job_timeout_ms,
-									    opts);
+								    opts,
+								    XE_SRIOV_SCHED_PRIORITY_LOW);
 	const unsigned int k = select_inflight_k(job_sched_params.duration_ms,
 						 opts->inflight, false);
 
-	igt_info("eq=%ums pt=%uus duration=%ums repeats=%d inflight=%u num_vfs=%d job_timeout=%ums\n",
+	igt_info("eq=%ums pt=%uus prio=%s duration=%ums repeats=%d inflight=%u num_vfs=%d job_timeout=%ums\n",
 		 job_sched_params.sched_params.exec_quantum_ms,
 		 job_sched_params.sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(job_sched_params.sched_params.priority),
 		 job_sched_params.duration_ms, job_sched_params.num_repeats,
 		 k, num_vfs + 1, job_timeout_ms);
 
@@ -759,16 +771,19 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
 {
 	struct subm_set set_ = {}, *set = &set_;
 	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
+	enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
 	struct vf_sched_params vf_sched_params = prepare_vf_sched_params(num_vfs, 1,
-									 job_timeout_ms, opts);
+									 job_timeout_ms, opts,
+									 priority);
 	uint64_t duration_ms = 2 * vf_sched_params.exec_quantum_ms +
 			       vf_sched_params.preempt_timeout_us / USEC_PER_MSEC;
 	int preemptible_end = 1;
 	uint8_t vf_ids[num_vfs + 1 /*PF*/];
 	const unsigned int k = select_inflight_k(duration_ms, opts->inflight, true);
 
-	igt_info("eq=%ums pt=%uus duration=%" PRIu64 "ms inflight=%u num_vfs=%d job_timeout=%ums\n",
+	igt_info("eq=%ums pt=%uus prio=%s duration=%" PRIu64 "ms inflight=%u num_vfs=%d job_timeout=%ums\n",
 		 vf_sched_params.exec_quantum_ms, vf_sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(vf_sched_params.priority),
 		 duration_ms, k, num_vfs, job_timeout_ms);
 
 	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
Signature · 1 line
2.43.0
Reviewed-by on v1 2/8
#5 lore raw

Re: [PATCH i-g-t 2/8] tests/intel/xe_sriov_scheduling: Add scheduling priority support

Quoted 39 lines · Marcin Bernatowicz

Extend vf_sched_params with scheduling priority and program it together with exec quantum and preempt timeout. Also print the selected priority in the test logs.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
  tests/intel/xe_sriov_scheduling.c | 31 +++++++++++++++++++++++--------
  1 file changed, 23 insertions(+), 8 deletions(-)
tests/intel/xe_sriov_scheduling.c +7 -0
index 509d6fd00..f4e674fe2 100644
@@ -370,6 +370,7 @@ static void init_vf_ids(uint8_t *array, size_t n,
  struct vf_sched_params {
  	uint32_t exec_quantum_ms;
  	uint32_t preempt_timeout_us;
+	enum xe_sriov_sched_priority priority;
  };
 
  static int __set_vfs_scheduling_params(int pf_fd, int num_vfs,
@@ -389,6 +390,12 @@ static int __set_vfs_scheduling_params(int pf_fd, int num_vfs,
  			  p->preempt_timeout_us, ret))
  		return ret;
 
+	ret = __xe_sriov_admin_bulk_set_sched_priority(pf_fd, p->priority);
+	if (igt_warn_on_f(ret,
+			  "Failed to bulk set sched priority=%d: %d\n",
+			  p->priority, ret))
+		return ret;
+
  	return ret;
  }
 
@@ -607,10 +614,12 @@ static unsigned int select_inflight_k(unsigned int duration_ms,
  static struct vf_sched_params prepare_vf_sched_params(int num_threads,

tests/intel/xe_sriov_scheduling.c static unsigned int select_inflight_k(unsigned int duration_ms, · line 622

Quoted 10 lines
tests/intel/xe_sriov_scheduling.c +4 -2
  						      int min_num_repeats,
  						      int job_timeout_ms,
-						      const struct subm_opts *opts)
+						      const struct subm_opts *opts,
+						      enum xe_sriov_sched_priority priority)
  {
  	struct vf_sched_params params = { MIN_EXEC_QUANTUM_MS,
-					  derive_preempt_timeout_us(MIN_EXEC_QUANTUM_MS) };
+					  derive_preempt_timeout_us(MIN_EXEC_QUANTUM_MS),
+						  priority };

Fix indentation

Quoted 6 lines
tests/intel/xe_sriov_scheduling.c +0 -0
  	if (opts->exec_quantum_ms || opts->preempt_timeout_us) {
  		if (opts->exec_quantum_ms)
@@ -638,12 +647,13 @@ static struct vf_sched_params prepare_vf_sched_params(int num_threads,
  }
 

tests/intel/xe_sriov_scheduling.c static struct vf_sched_params prepare_vf_sched_params(int num_threads, · line 656

Quoted 10 lines
tests/intel/xe_sriov_scheduling.c +3 -2
  static struct job_sched_params
-prepare_job_sched_params(int num_threads, int job_timeout_ms, const struct subm_opts *opts)
+prepare_job_sched_params(int num_threads, int job_timeout_ms, const struct subm_opts *opts,
+			 enum xe_sriov_sched_priority priority)
  {
  	struct job_sched_params params = { };
 
  	params.sched_params = prepare_vf_sched_params(num_threads, MIN_NUM_REPEATS,
-						      job_timeout_ms, opts);
+							      job_timeout_ms, opts, priority);

Fix indentation

tests/intel/xe_sriov_scheduling.c static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opt · line 677

Quoted 10 lines
tests/intel/xe_sriov_scheduling.c +2 -1
  	params.duration_ms = calculate_job_duration_ms(params.sched_params.exec_quantum_ms);
  	params.num_repeats = adjust_num_repeats(params.duration_ms, num_threads);
 
@@ -663,13 +673,15 @@ static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opt
  	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
  	struct job_sched_params job_sched_params = prepare_job_sched_params(num_vfs + 1,
  									    job_timeout_ms,
-									    opts);
+								    opts,
+								    XE_SRIOV_SCHED_PRIORITY_LOW);

Fix indentation

With above fixed:

Quoted 33 lines
tests/intel/xe_sriov_scheduling.c +7 -3
  	const unsigned int k = select_inflight_k(job_sched_params.duration_ms,
  						 opts->inflight, false);
 
-	igt_info("eq=%ums pt=%uus duration=%ums repeats=%d inflight=%u num_vfs=%d job_timeout=%ums\n",
+	igt_info("eq=%ums pt=%uus prio=%s duration=%ums repeats=%d inflight=%u num_vfs=%d job_timeout=%ums\n",
  		 job_sched_params.sched_params.exec_quantum_ms,
  		 job_sched_params.sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(job_sched_params.sched_params.priority),
  		 job_sched_params.duration_ms, job_sched_params.num_repeats,
  		 k, num_vfs + 1, job_timeout_ms);
 
@@ -759,16 +771,19 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
  {
  	struct subm_set set_ = {}, *set = &set_;
  	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
+	enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
  	struct vf_sched_params vf_sched_params = prepare_vf_sched_params(num_vfs, 1,
-									 job_timeout_ms, opts);
+									 job_timeout_ms, opts,
+									 priority);
  	uint64_t duration_ms = 2 * vf_sched_params.exec_quantum_ms +
  			       vf_sched_params.preempt_timeout_us / USEC_PER_MSEC;
  	int preemptible_end = 1;
  	uint8_t vf_ids[num_vfs + 1 /*PF*/];
  	const unsigned int k = select_inflight_k(duration_ms, opts->inflight, true);
 
-	igt_info("eq=%ums pt=%uus duration=%" PRIu64 "ms inflight=%u num_vfs=%d job_timeout=%ums\n",
+	igt_info("eq=%ums pt=%uus prio=%s duration=%" PRIu64 "ms inflight=%u num_vfs=%d job_timeout=%ums\n",
  		 vf_sched_params.exec_quantum_ms, vf_sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(vf_sched_params.priority),
  		 duration_ms, k, num_vfs, job_timeout_ms);
 
  	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
#6 lore raw

PATCH 3/8 tests/intel/xe_sriov_scheduling: Make sysfs_get_job_timeout_ms take const eci

In reply to Marcin Bernatowicz

Mark the eci parameter as const since it is not modified by the function.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/intel/xe_sriov_scheduling.c +1 -1
index f4e674fe2..f7cca95ae 100644
@@ -531,7 +531,7 @@ struct job_sched_params {
 	struct vf_sched_params sched_params;
 };
 
-static uint32_t sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)
+static uint32_t sysfs_get_job_timeout_ms(int fd, const struct drm_xe_engine_class_instance *eci)
 {
 	int engine_dir;
 	uint32_t ret;
Signature · 1 line
2.43.0
Reviewed-by on v1 3/8
#7 lore raw

Re: [PATCH i-g-t 3/8] tests/intel/xe_sriov_scheduling: Make sysfs_get_job_timeout_ms take const eci

Quoted 6 lines · Marcin Bernatowicz

Mark the eci parameter as const since it is not modified by the function.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 17 lines
---
  tests/intel/xe_sriov_scheduling.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
tests/intel/xe_sriov_scheduling.c +1 -1
index f4e674fe2..f7cca95ae 100644
@@ -531,7 +531,7 @@ struct job_sched_params {
  	struct vf_sched_params sched_params;
  };
 
-static uint32_t sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)
+static uint32_t sysfs_get_job_timeout_ms(int fd, const struct drm_xe_engine_class_instance *eci)
  {
  	int engine_dir;
  	uint32_t ret;
#8 lore raw

PATCH 4/8 tests/intel/xe_sriov_scheduling: Add PMU-based verification helpers

In reply to Marcin Bernatowicz

Add Xe PMU helper infrastructure to collect per-VF engine-active-ticks and engine-total-ticks over the workload measurement window.

Use the collected counters to derive per-VF runtime shares and cross-check them against throughput shares computed from workload completion statistics, strengthening scheduling validation.

Keep this verification optional by enabling it only when the required Xe perf events are available.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 433 ++++++++++++++++++++++++++++++
 1 file changed, 433 insertions(+)
tests/intel/xe_sriov_scheduling.c +433 -0
index f7cca95ae..6d8b7640d 100644
@@ -3,6 +3,7 @@
  * Copyright © 2025 Intel Corporation
  */
 #include "igt.h"
+#include "igt_perf.h"
 #include "igt_sriov_device.h"
 #include "igt_syncobj.h"
 #include "igt_sysfs.h"
@@ -660,6 +661,438 @@ prepare_job_sched_params(int num_threads, int job_timeout_ms, const struct subm_
 	return params;
 }
 
+struct vf_config {
+	unsigned int vf_id;
+	struct vf_sched_params sched_params;
+	bool run_workload;
+};
+
+struct runtime_metrics {
+	unsigned int vf_id;
+	uint64_t engine_active_ticks;
+	uint64_t engine_total_ticks;
+	double measured_total_tick_share;
+	double active_to_total_ratio;
+	double measured_throughput_share;
+	double expected_throughput_share;
+	double expected_active_to_total_ratio;
+	double expected_total_tick_share;
+};
+
+struct perf_counters {
+	int pmu_fd[2];
+	uint64_t before[2];
+	uint64_t after[2];
+};
+
+static char perf_device[NAME_MAX];
+
+static bool has_perf_event(const char *device, const char *event)
+{
+	char path[512];
+
+	snprintf(path, sizeof(path),
+		 "/sys/bus/event_source/devices/%s/events/%s",
+		 device, event);
+
+	return access(path, F_OK) == 0;
+}
+
+static int perf_open_group(int xe, uint64_t config, int group)
+{
+	int fd;
+
+	fd = igt_perf_open_group(xe_perf_type_id(xe), config, group);
+	igt_skip_on(fd < 0 && errno == ENODEV);
+	igt_assert_fd(fd);
+
+	return fd;
+}
+
+static uint64_t perf_read_values(int fd, unsigned int num, uint64_t *val)
+{
+	uint64_t buf[2 + num];
+	unsigned int i;
+
+	igt_assert_eq(read(fd, buf, sizeof(buf)), sizeof(buf));
+
+	for (i = 0; i < num; i++)
+		val[i] = buf[2 + i];
+
+	return buf[1];
+}
+
+static uint64_t perf_add_format_config(const char *format, uint64_t val)
+{
+	uint64_t config;
+	uint32_t shift;
+	int ret;
+
+	ret = perf_event_format(perf_device, format, &shift);
+	igt_assert(ret >= 0);
+	config = val << shift;
+
+	return config;
+}
+
+static uint64_t perf_get_event_config(unsigned int gt,
+				      const struct drm_xe_engine_class_instance *eci,
+				      const char *event)
+{
+	uint64_t perf_config = 0;
+	int ret;
+
+	ret = perf_event_config(perf_device, event, &perf_config);
+	igt_assert(ret >= 0);
+	perf_config |= perf_add_format_config("gt", gt);
+
+	if (eci) {
+		perf_config |= perf_add_format_config("engine_class", eci->engine_class);
+		perf_config |= perf_add_format_config("engine_instance", eci->engine_instance);
+	}
+
+	return perf_config;
+}
+
+static uint64_t perf_get_event_config_vf(unsigned int gt, unsigned int vf_id,
+					 const struct drm_xe_engine_class_instance *eci,
+					 const char *event)
+{
+	return perf_get_event_config(gt, eci, event) |
+	       perf_add_format_config("function", vf_id);
+}
+
+static double expected_total_tick_weight(const struct vf_config *config)
+{
+	return config->sched_params.exec_quantum_ms;
+}
+
+static double expected_throughput_weight(const struct vf_config *config)
+{
+	if (!config->run_workload)
+		return 0.0;
+
+	return config->sched_params.exec_quantum_ms;
+}
+
+static void init_perf_counters(int pf_fd,
+			       const struct drm_xe_engine_class_instance *eci,
+			       const struct vf_config *configs,
+			       size_t num_configs,
+			       struct perf_counters *counters)
+{
+	int leader = -1;
+
+	for (size_t i = 0; i < num_configs; i++) {
+		uint64_t config;
+
+		counters[i].pmu_fd[0] = -1;
+		counters[i].pmu_fd[1] = -1;
+
+		config = perf_get_event_config_vf(eci->gt_id, configs[i].vf_id, eci,
+						  "engine-active-ticks");
+		counters[i].pmu_fd[0] = perf_open_group(pf_fd, config, leader);
+		if (leader < 0)
+			leader = counters[i].pmu_fd[0];
+
+		config = perf_get_event_config_vf(eci->gt_id, configs[i].vf_id, eci,
+						  "engine-total-ticks");
+		counters[i].pmu_fd[1] = perf_open_group(pf_fd, config, leader);
+	}
+}
+
+static void fini_perf_counters(struct perf_counters *counters,
+			       size_t num_configs)
+{
+	for (size_t i = 0; i < num_configs; i++) {
+		if (counters[i].pmu_fd[0] >= 0)
+			close(counters[i].pmu_fd[0]);
+		if (counters[i].pmu_fd[1] >= 0)
+			close(counters[i].pmu_fd[1]);
+	}
+}
+
+static uint64_t start_perf_counters(struct perf_counters *counters,
+				    size_t num_configs)
+{
+	uint64_t values[2 * num_configs];
+
+	perf_read_values(counters[0].pmu_fd[0], 2 * num_configs, values);
+
+	for (size_t i = 0; i < num_configs; i++) {
+		counters[i].before[0] = values[2 * i];
+		counters[i].before[1] = values[2 * i + 1];
+	}
+
+	return current_timestamp_ns();
+}
+
+static void
+init_expected_runtime_metrics(const struct vf_config *configs,
+			      size_t num_configs,
+			      struct runtime_metrics *metrics)
+{
+	double total_expected_total_tick_weight = 0.0;
+	double total_expected_throughput_weight = 0.0;
+
+	for (size_t i = 0; i < num_configs; i++) {
+		total_expected_total_tick_weight += expected_total_tick_weight(&configs[i]);
+		total_expected_throughput_weight += expected_throughput_weight(&configs[i]);
+	}
+
+	for (size_t i = 0; i < num_configs; i++) {
+		metrics[i].vf_id = configs[i].vf_id;
+		metrics[i].expected_throughput_share = total_expected_throughput_weight ?
+			expected_throughput_weight(&configs[i]) /
+			total_expected_throughput_weight : 0.0;
+		metrics[i].expected_total_tick_share = total_expected_total_tick_weight ?
+			expected_total_tick_weight(&configs[i]) /
+			total_expected_total_tick_weight : 0.0;
+		metrics[i].expected_active_to_total_ratio =
+			configs[i].sched_params.priority == XE_SRIOV_SCHED_PRIORITY_NORMAL ?
+				(configs[i].run_workload ? 1.0 : 0.0) :
+				(metrics[i].expected_total_tick_share ?
+				 metrics[i].expected_throughput_share /
+				 metrics[i].expected_total_tick_share : 0.0);
+	}
+}
+
+static void compute_perf_metrics(const struct vf_config *configs,
+				 const struct perf_counters *counters,
+				 size_t num_configs,
+				 struct runtime_metrics *metrics)
+{
+	uint64_t total_engine_total_ticks = 0;
+
+	init_expected_runtime_metrics(configs, num_configs, metrics);
+
+	for (size_t i = 0; i < num_configs; i++) {
+		metrics[i].engine_active_ticks = counters[i].after[0] - counters[i].before[0];
+		metrics[i].engine_total_ticks = counters[i].after[1] - counters[i].before[1];
+		total_engine_total_ticks += metrics[i].engine_total_ticks;
+	}
+
+	for (size_t i = 0; i < num_configs; i++) {
+		metrics[i].active_to_total_ratio = metrics[i].engine_total_ticks ?
+			(double)metrics[i].engine_active_ticks /
+			metrics[i].engine_total_ticks : 0.0;
+		metrics[i].measured_total_tick_share = total_engine_total_ticks ?
+			(double)metrics[i].engine_total_ticks /
+			total_engine_total_ticks : 0.0;
+
+		igt_info("%s actual={active_ticks=%" PRIu64 ",total_ticks=%" PRIu64
+			 ",active/total=%.4f,total_share=%.4f} "
+			 "expected={active/total=%.4f,total_share=%.4f,throughput_share=%.4f}\n",
+			 igt_sriov_func_str(configs[i].vf_id),
+			 metrics[i].engine_active_ticks, metrics[i].engine_total_ticks,
+			 metrics[i].active_to_total_ratio,
+			 metrics[i].measured_total_tick_share,
+			 metrics[i].expected_active_to_total_ratio,
+			 metrics[i].expected_total_tick_share,
+			 metrics[i].expected_throughput_share);
+	}
+}
+
+static uint64_t stop_perf_counters(const struct vf_config *configs,
+				   struct perf_counters *counters,
+				   size_t num_configs,
+				   struct runtime_metrics *metrics)
+{
+	uint64_t end_timestamp = current_timestamp_ns();
+	uint64_t values[2 * num_configs];
+
+	perf_read_values(counters[0].pmu_fd[0], 2 * num_configs, values);
+
+	for (size_t i = 0; i < num_configs; i++) {
+		counters[i].after[0] = values[2 * i];
+		counters[i].after[1] = values[2 * i + 1];
+	}
+
+	compute_perf_metrics(configs, counters, num_configs, metrics);
+
+	return end_timestamp;
+}
+
+static void init_vf_configs_from_set(int pf_fd,
+				     const struct subm_set *set,
+				     struct vf_config *configs)
+{
+	const struct drm_xe_engine_class_instance *eci = &set->data[0].subm.hwe;
+
+	for (int n = 0; n < set->ndata; ++n) {
+		const struct subm *subm = &set->data[n].subm;
+		const int vf_num = subm->vf_num;
+
+		igt_assert_eq(subm->hwe.gt_id, eci->gt_id);
+		igt_assert_eq(subm->hwe.engine_class, eci->engine_class);
+		igt_assert_eq(subm->hwe.engine_instance, eci->engine_instance);
+		configs[n] = (struct vf_config) {
+			.vf_id = vf_num,
+			.sched_params = {
+				.exec_quantum_ms = xe_sriov_admin_get_exec_quantum_ms(pf_fd,
+								      vf_num),
+				.preempt_timeout_us = xe_sriov_admin_get_preempt_timeout_us(pf_fd,
+									    vf_num),
+				.priority = xe_sriov_admin_get_sched_priority(pf_fd, vf_num, NULL),
+			},
+			.run_workload = true,
+		};
+	}
+}
+
+static unsigned int count_window_completions(const struct subm_stats *stats,
+					     uint64_t window_start,
+					     uint64_t window_end)
+{
+	unsigned int completions = 0;
+
+	for (int i = 0; i < stats->samples.n_values; i++) {
+		uint64_t cts = stats->complete_ts[i];
+
+		if (cts >= window_start && cts <= window_end)
+			completions++;
+	}
+
+	return completions;
+}
+
+static void compute_measured_throughput_share(const struct subm_set *set,
+					      uint64_t window_start,
+					      uint64_t window_end,
+					      struct runtime_metrics *metrics)
+{
+	unsigned int completions[set->ndata];
+	unsigned int total_completions = 0;
+
+	for (int n = 0; n < set->ndata; ++n) {
+		completions[n] = count_window_completions(&set->data[n].stats,
+							  window_start,
+							  window_end);
+		total_completions += completions[n];
+	}
+
+	for (int n = 0; n < set->ndata; ++n) {
+		metrics[n].measured_throughput_share = total_completions ?
+			(double)completions[n] / total_completions : 0.0;
+	}
+}
+
+static void compute_concurrent_rate_share(const struct subm_set *set,
+					  struct runtime_metrics *metrics)
+{
+	double total_rate = 0.0;
+
+	for (int n = 0; n < set->ndata; ++n)
+		total_rate += set->data[n].stats.concurrent_rate;
+
+	for (int n = 0; n < set->ndata; ++n) {
+		metrics[n].measured_throughput_share = total_rate ?
+			set->data[n].stats.concurrent_rate / total_rate : 0.0;
+	}
+}
+
+static void run_subm_set_and_collect_metrics(int pf_fd,
+					     struct subm_set *set,
+					     struct vf_config *vf_configs,
+					     struct runtime_metrics *metrics,
+					     bool verify_with_perf_counters,
+					     uint64_t *measurement_start_ns,
+					     uint64_t *measurement_end_ns)
+{
+	struct perf_counters *perf_counters = NULL;
+	const struct drm_xe_engine_class_instance *eci = &set->data[0].subm.hwe;
+
+	init_vf_configs_from_set(pf_fd, set, vf_configs);
+	init_expected_runtime_metrics(vf_configs, set->ndata, metrics);
+
+	if (verify_with_perf_counters) {
+		perf_counters = calloc(set->ndata, sizeof(*perf_counters));
+		igt_assert(perf_counters);
+		init_perf_counters(pf_fd, eci,
+				   vf_configs, set->ndata, perf_counters);
+		*measurement_start_ns = start_perf_counters(perf_counters,
+							    set->ndata);
+	}
+
+	subm_set_dispatch_and_wait_threads(set);
+
+	if (verify_with_perf_counters) {
+		*measurement_end_ns = stop_perf_counters(vf_configs,
+							 perf_counters,
+							 set->ndata,
+							 metrics);
+		fini_perf_counters(perf_counters, set->ndata);
+		free(perf_counters);
+	}
+
+	subm_set_close_handles(set);
+	compute_common_time_frame_stats(set);
+	compute_concurrent_rate_share(set, metrics);
+
+	if (verify_with_perf_counters)
+		compute_measured_throughput_share(set,
+						  *measurement_start_ns,
+						  *measurement_end_ns,
+						  metrics);
+}
+
+static void assert_share_matches_expected(const struct runtime_metrics *metrics,
+					  size_t num_metrics,
+					  double tolerance,
+					  bool use_total_tick_share)
+{
+	for (size_t n = 0; n < num_metrics; ++n) {
+		double measured_share = use_total_tick_share ?
+			metrics[n].measured_total_tick_share :
+			metrics[n].measured_throughput_share;
+		double expected_share = use_total_tick_share ?
+			metrics[n].expected_total_tick_share :
+			metrics[n].expected_throughput_share;
+		const char *share_name = use_total_tick_share ?
+			"total tick share" : "throughput share";
+
+		igt_assert_f(check_within_epsilon(measured_share,
+						  expected_share,
+						  tolerance),
+			     "%s=%0.4f not within +-%.0f%% of expected=%0.4f for %s\n",
+			     share_name, measured_share, tolerance * 100,
+			     expected_share,
+			     igt_sriov_func_str(metrics[n].vf_id));
+	}
+}
+
+static void assert_throughput_share_matches_total_tick(const struct runtime_metrics *metrics,
+						       size_t num_metrics,
+						       double tolerance)
+{
+	for (size_t n = 0; n < num_metrics; ++n) {
+		double expected_ratio = metrics[n].expected_total_tick_share ?
+			metrics[n].expected_throughput_share /
+			metrics[n].expected_total_tick_share : 0.0;
+		double expected_throughput_share =
+			metrics[n].measured_total_tick_share * expected_ratio;
+
+		assert_within_epsilon(metrics[n].measured_throughput_share,
+				      expected_throughput_share,
+				      tolerance);
+	}
+}
+
+static void warn_active_ticks_mismatch(const struct runtime_metrics *metrics,
+				       size_t num_metrics,
+				       double tolerance)
+{
+	for (size_t n = 0; n < num_metrics; ++n) {
+		igt_warn_on_f(!check_within_epsilon(metrics[n].active_to_total_ratio,
+						    metrics[n].expected_active_to_total_ratio,
+						    tolerance),
+			      "active/total=%0.4f not within +-%.0f%% of expected=%0.4f for %s\n",
+			      metrics[n].active_to_total_ratio, tolerance * 100,
+			      metrics[n].expected_active_to_total_ratio,
+			      igt_sriov_func_str(metrics[n].vf_id));
+	}
+}
+
 /**
  * SUBTEST: equal-throughput
  * Description:
Signature · 1 line
2.43.0
Reviewed-by on v1 4/8
#9 lore raw

Re: [PATCH i-g-t 4/8] tests/intel/xe_sriov_scheduling: Add PMU-based verification helpers

Quoted 7 lines · Marcin Bernatowicz

Add Xe PMU helper infrastructure to collect per-VF engine-active-ticks and engine-total-ticks over the workload measurement window.

Use the collected counters to derive per-VF runtime shares and cross-check them against throughput shares computed from workload completion statistics, strengthening scheduling validation.

Quoted 7 lines

Keep this verification optional by enabling it only when the required Xe perf events are available.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 455 lines
---
  tests/intel/xe_sriov_scheduling.c | 433 ++++++++++++++++++++++++++++++
  1 file changed, 433 insertions(+)
tests/intel/xe_sriov_scheduling.c +433 -0
index f7cca95ae..6d8b7640d 100644
@@ -3,6 +3,7 @@
   * Copyright © 2025 Intel Corporation
   */
  #include "igt.h"
+#include "igt_perf.h"
  #include "igt_sriov_device.h"
  #include "igt_syncobj.h"
  #include "igt_sysfs.h"
@@ -660,6 +661,438 @@ prepare_job_sched_params(int num_threads, int job_timeout_ms, const struct subm_
  	return params;
  }
 
+struct vf_config {
+	unsigned int vf_id;
+	struct vf_sched_params sched_params;
+	bool run_workload;
+};
+
+struct runtime_metrics {
+	unsigned int vf_id;
+	uint64_t engine_active_ticks;
+	uint64_t engine_total_ticks;
+	double measured_total_tick_share;
+	double active_to_total_ratio;
+	double measured_throughput_share;
+	double expected_throughput_share;
+	double expected_active_to_total_ratio;
+	double expected_total_tick_share;
+};
+
+struct perf_counters {
+	int pmu_fd[2];
+	uint64_t before[2];
+	uint64_t after[2];
+};
+
+static char perf_device[NAME_MAX];
+
+static bool has_perf_event(const char *device, const char *event)
+{
+	char path[512];
+
+	snprintf(path, sizeof(path),
+		 "/sys/bus/event_source/devices/%s/events/%s",
+		 device, event);
+
+	return access(path, F_OK) == 0;
+}
+
+static int perf_open_group(int xe, uint64_t config, int group)
+{
+	int fd;
+
+	fd = igt_perf_open_group(xe_perf_type_id(xe), config, group);
+	igt_skip_on(fd < 0 && errno == ENODEV);
+	igt_assert_fd(fd);
+
+	return fd;
+}
+
+static uint64_t perf_read_values(int fd, unsigned int num, uint64_t *val)
+{
+	uint64_t buf[2 + num];
+	unsigned int i;
+
+	igt_assert_eq(read(fd, buf, sizeof(buf)), sizeof(buf));
+
+	for (i = 0; i < num; i++)
+		val[i] = buf[2 + i];
+
+	return buf[1];
+}
+
+static uint64_t perf_add_format_config(const char *format, uint64_t val)
+{
+	uint64_t config;
+	uint32_t shift;
+	int ret;
+
+	ret = perf_event_format(perf_device, format, &shift);
+	igt_assert(ret >= 0);
+	config = val << shift;
+
+	return config;
+}
+
+static uint64_t perf_get_event_config(unsigned int gt,
+				      const struct drm_xe_engine_class_instance *eci,
+				      const char *event)
+{
+	uint64_t perf_config = 0;
+	int ret;
+
+	ret = perf_event_config(perf_device, event, &perf_config);
+	igt_assert(ret >= 0);
+	perf_config |= perf_add_format_config("gt", gt);
+
+	if (eci) {
+		perf_config |= perf_add_format_config("engine_class", eci->engine_class);
+		perf_config |= perf_add_format_config("engine_instance", eci->engine_instance);
+	}
+
+	return perf_config;
+}
+
+static uint64_t perf_get_event_config_vf(unsigned int gt, unsigned int vf_id,
+					 const struct drm_xe_engine_class_instance *eci,
+					 const char *event)
+{
+	return perf_get_event_config(gt, eci, event) |
+	       perf_add_format_config("function", vf_id);
+}
+
+static double expected_total_tick_weight(const struct vf_config *config)
+{
+	return config->sched_params.exec_quantum_ms;
+}
+
+static double expected_throughput_weight(const struct vf_config *config)
+{
+	if (!config->run_workload)
+		return 0.0;
+
+	return config->sched_params.exec_quantum_ms;
+}
+
+static void init_perf_counters(int pf_fd,
+			       const struct drm_xe_engine_class_instance *eci,
+			       const struct vf_config *configs,
+			       size_t num_configs,
+			       struct perf_counters *counters)
+{
+	int leader = -1;
+
+	for (size_t i = 0; i < num_configs; i++) {
+		uint64_t config;
+
+		counters[i].pmu_fd[0] = -1;
+		counters[i].pmu_fd[1] = -1;
+
+		config = perf_get_event_config_vf(eci->gt_id, configs[i].vf_id, eci,
+						  "engine-active-ticks");
+		counters[i].pmu_fd[0] = perf_open_group(pf_fd, config, leader);
+		if (leader < 0)
+			leader = counters[i].pmu_fd[0];
+
+		config = perf_get_event_config_vf(eci->gt_id, configs[i].vf_id, eci,
+						  "engine-total-ticks");
+		counters[i].pmu_fd[1] = perf_open_group(pf_fd, config, leader);
+	}
+}
+
+static void fini_perf_counters(struct perf_counters *counters,
+			       size_t num_configs)
+{
+	for (size_t i = 0; i < num_configs; i++) {
+		if (counters[i].pmu_fd[0] >= 0)
+			close(counters[i].pmu_fd[0]);
+		if (counters[i].pmu_fd[1] >= 0)
+			close(counters[i].pmu_fd[1]);
+	}
+}
+
+static uint64_t start_perf_counters(struct perf_counters *counters,
+				    size_t num_configs)
+{
+	uint64_t values[2 * num_configs];
+
+	perf_read_values(counters[0].pmu_fd[0], 2 * num_configs, values);
+
+	for (size_t i = 0; i < num_configs; i++) {
+		counters[i].before[0] = values[2 * i];
+		counters[i].before[1] = values[2 * i + 1];
+	}
+
+	return current_timestamp_ns();
+}
+
+static void
+init_expected_runtime_metrics(const struct vf_config *configs,
+			      size_t num_configs,
+			      struct runtime_metrics *metrics)
+{
+	double total_expected_total_tick_weight = 0.0;
+	double total_expected_throughput_weight = 0.0;
+
+	for (size_t i = 0; i < num_configs; i++) {
+		total_expected_total_tick_weight += expected_total_tick_weight(&configs[i]);
+		total_expected_throughput_weight += expected_throughput_weight(&configs[i]);
+	}
+
+	for (size_t i = 0; i < num_configs; i++) {
+		metrics[i].vf_id = configs[i].vf_id;
+		metrics[i].expected_throughput_share = total_expected_throughput_weight ?
+			expected_throughput_weight(&configs[i]) /
+			total_expected_throughput_weight : 0.0;
+		metrics[i].expected_total_tick_share = total_expected_total_tick_weight ?
+			expected_total_tick_weight(&configs[i]) /
+			total_expected_total_tick_weight : 0.0;
+		metrics[i].expected_active_to_total_ratio =
+			configs[i].sched_params.priority == XE_SRIOV_SCHED_PRIORITY_NORMAL ?
+				(configs[i].run_workload ? 1.0 : 0.0) :
+				(metrics[i].expected_total_tick_share ?
+				 metrics[i].expected_throughput_share /
+				 metrics[i].expected_total_tick_share : 0.0);
+	}
+}
+
+static void compute_perf_metrics(const struct vf_config *configs,
+				 const struct perf_counters *counters,
+				 size_t num_configs,
+				 struct runtime_metrics *metrics)
+{
+	uint64_t total_engine_total_ticks = 0;
+
+	init_expected_runtime_metrics(configs, num_configs, metrics);
+
+	for (size_t i = 0; i < num_configs; i++) {
+		metrics[i].engine_active_ticks = counters[i].after[0] - counters[i].before[0];
+		metrics[i].engine_total_ticks = counters[i].after[1] - counters[i].before[1];
+		total_engine_total_ticks += metrics[i].engine_total_ticks;
+	}
+
+	for (size_t i = 0; i < num_configs; i++) {
+		metrics[i].active_to_total_ratio = metrics[i].engine_total_ticks ?
+			(double)metrics[i].engine_active_ticks /
+			metrics[i].engine_total_ticks : 0.0;
+		metrics[i].measured_total_tick_share = total_engine_total_ticks ?
+			(double)metrics[i].engine_total_ticks /
+			total_engine_total_ticks : 0.0;
+
+		igt_info("%s actual={active_ticks=%" PRIu64 ",total_ticks=%" PRIu64
+			 ",active/total=%.4f,total_share=%.4f} "
+			 "expected={active/total=%.4f,total_share=%.4f,throughput_share=%.4f}\n",
+			 igt_sriov_func_str(configs[i].vf_id),
+			 metrics[i].engine_active_ticks, metrics[i].engine_total_ticks,
+			 metrics[i].active_to_total_ratio,
+			 metrics[i].measured_total_tick_share,
+			 metrics[i].expected_active_to_total_ratio,
+			 metrics[i].expected_total_tick_share,
+			 metrics[i].expected_throughput_share);
+	}
+}
+
+static uint64_t stop_perf_counters(const struct vf_config *configs,
+				   struct perf_counters *counters,
+				   size_t num_configs,
+				   struct runtime_metrics *metrics)
+{
+	uint64_t end_timestamp = current_timestamp_ns();
+	uint64_t values[2 * num_configs];
+
+	perf_read_values(counters[0].pmu_fd[0], 2 * num_configs, values);
+
+	for (size_t i = 0; i < num_configs; i++) {
+		counters[i].after[0] = values[2 * i];
+		counters[i].after[1] = values[2 * i + 1];
+	}
+
+	compute_perf_metrics(configs, counters, num_configs, metrics);
+
+	return end_timestamp;
+}
+
+static void init_vf_configs_from_set(int pf_fd,
+				     const struct subm_set *set,
+				     struct vf_config *configs)
+{
+	const struct drm_xe_engine_class_instance *eci = &set->data[0].subm.hwe;
+
+	for (int n = 0; n < set->ndata; ++n) {
+		const struct subm *subm = &set->data[n].subm;
+		const int vf_num = subm->vf_num;
+
+		igt_assert_eq(subm->hwe.gt_id, eci->gt_id);
+		igt_assert_eq(subm->hwe.engine_class, eci->engine_class);
+		igt_assert_eq(subm->hwe.engine_instance, eci->engine_instance);
+		configs[n] = (struct vf_config) {
+			.vf_id = vf_num,
+			.sched_params = {
+				.exec_quantum_ms = xe_sriov_admin_get_exec_quantum_ms(pf_fd,
+								      vf_num),
+				.preempt_timeout_us = xe_sriov_admin_get_preempt_timeout_us(pf_fd,
+									    vf_num),
+				.priority = xe_sriov_admin_get_sched_priority(pf_fd, vf_num, NULL),
+			},
+			.run_workload = true,
+		};
+	}
+}
+
+static unsigned int count_window_completions(const struct subm_stats *stats,
+					     uint64_t window_start,
+					     uint64_t window_end)
+{
+	unsigned int completions = 0;
+
+	for (int i = 0; i < stats->samples.n_values; i++) {
+		uint64_t cts = stats->complete_ts[i];
+
+		if (cts >= window_start && cts <= window_end)
+			completions++;
+	}
+
+	return completions;
+}
+
+static void compute_measured_throughput_share(const struct subm_set *set,
+					      uint64_t window_start,
+					      uint64_t window_end,
+					      struct runtime_metrics *metrics)
+{
+	unsigned int completions[set->ndata];
+	unsigned int total_completions = 0;
+
+	for (int n = 0; n < set->ndata; ++n) {
+		completions[n] = count_window_completions(&set->data[n].stats,
+							  window_start,
+							  window_end);
+		total_completions += completions[n];
+	}
+
+	for (int n = 0; n < set->ndata; ++n) {
+		metrics[n].measured_throughput_share = total_completions ?
+			(double)completions[n] / total_completions : 0.0;
+	}
+}
+
+static void compute_concurrent_rate_share(const struct subm_set *set,
+					  struct runtime_metrics *metrics)
+{
+	double total_rate = 0.0;
+
+	for (int n = 0; n < set->ndata; ++n)
+		total_rate += set->data[n].stats.concurrent_rate;
+
+	for (int n = 0; n < set->ndata; ++n) {
+		metrics[n].measured_throughput_share = total_rate ?
+			set->data[n].stats.concurrent_rate / total_rate : 0.0;
+	}
+}
+
+static void run_subm_set_and_collect_metrics(int pf_fd,
+					     struct subm_set *set,
+					     struct vf_config *vf_configs,
+					     struct runtime_metrics *metrics,
+					     bool verify_with_perf_counters,
+					     uint64_t *measurement_start_ns,
+					     uint64_t *measurement_end_ns)
+{
+	struct perf_counters *perf_counters = NULL;
+	const struct drm_xe_engine_class_instance *eci = &set->data[0].subm.hwe;
+
+	init_vf_configs_from_set(pf_fd, set, vf_configs);
+	init_expected_runtime_metrics(vf_configs, set->ndata, metrics);
+
+	if (verify_with_perf_counters) {
+		perf_counters = calloc(set->ndata, sizeof(*perf_counters));
+		igt_assert(perf_counters);
+		init_perf_counters(pf_fd, eci,
+				   vf_configs, set->ndata, perf_counters);
+		*measurement_start_ns = start_perf_counters(perf_counters,
+							    set->ndata);
+	}
+
+	subm_set_dispatch_and_wait_threads(set);
+
+	if (verify_with_perf_counters) {
+		*measurement_end_ns = stop_perf_counters(vf_configs,
+							 perf_counters,
+							 set->ndata,
+							 metrics);
+		fini_perf_counters(perf_counters, set->ndata);
+		free(perf_counters);
+	}
+
+	subm_set_close_handles(set);
+	compute_common_time_frame_stats(set);
+	compute_concurrent_rate_share(set, metrics);
+
+	if (verify_with_perf_counters)
+		compute_measured_throughput_share(set,
+						  *measurement_start_ns,
+						  *measurement_end_ns,
+						  metrics);
+}
+
+static void assert_share_matches_expected(const struct runtime_metrics *metrics,
+					  size_t num_metrics,
+					  double tolerance,
+					  bool use_total_tick_share)
+{
+	for (size_t n = 0; n < num_metrics; ++n) {
+		double measured_share = use_total_tick_share ?
+			metrics[n].measured_total_tick_share :
+			metrics[n].measured_throughput_share;
+		double expected_share = use_total_tick_share ?
+			metrics[n].expected_total_tick_share :
+			metrics[n].expected_throughput_share;
+		const char *share_name = use_total_tick_share ?
+			"total tick share" : "throughput share";
+
+		igt_assert_f(check_within_epsilon(measured_share,
+						  expected_share,
+						  tolerance),
+			     "%s=%0.4f not within +-%.0f%% of expected=%0.4f for %s\n",
+			     share_name, measured_share, tolerance * 100,
+			     expected_share,
+			     igt_sriov_func_str(metrics[n].vf_id));
+	}
+}
+
+static void assert_throughput_share_matches_total_tick(const struct runtime_metrics *metrics,
+						       size_t num_metrics,
+						       double tolerance)
+{
+	for (size_t n = 0; n < num_metrics; ++n) {
+		double expected_ratio = metrics[n].expected_total_tick_share ?
+			metrics[n].expected_throughput_share /
+			metrics[n].expected_total_tick_share : 0.0;
+		double expected_throughput_share =
+			metrics[n].measured_total_tick_share * expected_ratio;
+
+		assert_within_epsilon(metrics[n].measured_throughput_share,
+				      expected_throughput_share,
+				      tolerance);
+	}
+}
+
+static void warn_active_ticks_mismatch(const struct runtime_metrics *metrics,
+				       size_t num_metrics,
+				       double tolerance)
+{
+	for (size_t n = 0; n < num_metrics; ++n) {
+		igt_warn_on_f(!check_within_epsilon(metrics[n].active_to_total_ratio,
+						    metrics[n].expected_active_to_total_ratio,
+						    tolerance),
+			      "active/total=%0.4f not within +-%.0f%% of expected=%0.4f for %s\n",
+			      metrics[n].active_to_total_ratio, tolerance * 100,
+			      metrics[n].expected_active_to_total_ratio,
+			      igt_sriov_func_str(metrics[n].vf_id));
+	}
+}
+
  /**
   * SUBTEST: equal-throughput
   * Description:
#10 lore raw

PATCH 5/8 tests/intel/xe_sriov_scheduling: Raise min exec quantum to 2ms

In reply to Marcin Bernatowicz

Increase MIN_EXEC_QUANTUM_MS from 1 to 2 to reduce PMU active/total ratio noise and avoid false positives.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/intel/xe_sriov_scheduling.c +1 -1
index 6d8b7640d..9550c8e58 100644
@@ -519,7 +519,7 @@ static void log_sample_values(char *id, struct subm_stats *stats,
 }
 
 #define MIN_NUM_REPEATS 25
-#define MIN_EXEC_QUANTUM_MS 1
+#define MIN_EXEC_QUANTUM_MS 2
 #define MAX_EXEC_QUANTUM_MS 32
 #define MIN_JOB_DURATION_MS 2
 #define MAX_TOTAL_DURATION_MS 15000
Signature · 1 line
2.43.0
Reviewed-by on v1 5/8
#11 lore raw

Re: [PATCH i-g-t 5/8] tests/intel/xe_sriov_scheduling: Raise min exec quantum to 2ms

Quoted 7 lines · Marcin Bernatowicz

Increase MIN_EXEC_QUANTUM_MS from 1 to 2 to reduce PMU active/total ratio noise and avoid false positives.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 17 lines
---
  tests/intel/xe_sriov_scheduling.c | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
tests/intel/xe_sriov_scheduling.c +1 -1
index 6d8b7640d..9550c8e58 100644
@@ -519,7 +519,7 @@ static void log_sample_values(char *id, struct subm_stats *stats,
  }
 
  #define MIN_NUM_REPEATS 25
-#define MIN_EXEC_QUANTUM_MS 1
+#define MIN_EXEC_QUANTUM_MS 2
  #define MAX_EXEC_QUANTUM_MS 32
  #define MIN_JOB_DURATION_MS 2
  #define MAX_TOTAL_DURATION_MS 15000
#12 lore raw

PATCH 6/8 tests/intel/xe_sriov_scheduling: Refactor throughput_ratio and nonpreempt-engine-resets test

In reply to Marcin Bernatowicz

Extract verify_applied_scheduling_behavior so equal-throughput and default-enabled-fair-scheduling share common verification logic.

Increase coverage with verification across all GTs and both low/normal scheduling priorities.

Strengthen confidence in results with PMU-based checks using engine-active-ticks and engine-total-ticks metrics (when available).

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 373 ++++++++++++++++++++----------
 1 file changed, 255 insertions(+), 118 deletions(-)
tests/intel/xe_sriov_scheduling.c +255 -118
index 9550c8e58..692f92e76 100644
@@ -158,6 +158,7 @@ static void subm_fini(struct subm *s)
 static void subm_workload_init(struct subm *s, struct subm_work_desc *work)
 {
 	s->work = *work;
+
 	s->expected_ticks = xe_spin_nsec_to_ticks(s->fd, s->hwe.gt_id,
 						  s->work.duration_ms * 1000000);
 	for (unsigned int i = 0; i < s->slots; i++)
@@ -1093,48 +1094,35 @@ static void warn_active_ticks_mismatch(const struct runtime_metrics *metrics,
 	}
 }
 
-/**
- * SUBTEST: equal-throughput
- * Description:
- *   Check all VFs with same scheduling settings running same workload
- *   achieve the same throughput.
- */
-static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opts)
+static void verify_applied_scheduling_behavior(int pf_fd,
+					       const uint8_t *vf_ids,
+					       size_t num_functions,
+					       const struct subm_opts *opts,
+					       bool verify_with_perf_counters,
+					       const struct drm_xe_engine_class_instance *eci,
+					       const struct job_sched_params *job_sched_params)
 {
 	struct subm_set set_ = {}, *set = &set_;
-	uint8_t vf_ids[num_vfs + 1 /*PF*/];
-	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
-	struct job_sched_params job_sched_params = prepare_job_sched_params(num_vfs + 1,
-									    job_timeout_ms,
-								    opts,
-								    XE_SRIOV_SCHED_PRIORITY_LOW);
-	const unsigned int k = select_inflight_k(job_sched_params.duration_ms,
-						 opts->inflight, false);
-
-	igt_info("eq=%ums pt=%uus prio=%s duration=%ums repeats=%d inflight=%u num_vfs=%d job_timeout=%ums\n",
-		 job_sched_params.sched_params.exec_quantum_ms,
-		 job_sched_params.sched_params.preempt_timeout_us,
-		 xe_sriov_sched_priority_to_string(job_sched_params.sched_params.priority),
-		 job_sched_params.duration_ms, job_sched_params.num_repeats,
-		 k, num_vfs + 1, job_timeout_ms);
-
-	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
-		    &(struct init_vf_ids_opts){ .shuffle = true,
-						.shuffle_pf = true });
-	xe_sriov_require_default_scheduling_attributes(pf_fd);
-	/* enable VFs */
-	igt_sriov_disable_driver_autoprobe(pf_fd);
-	igt_sriov_enable_vfs(pf_fd, num_vfs);
-	/* set scheduling params (PF and VFs) */
-	set_vfs_scheduling_params(pf_fd, num_vfs, &job_sched_params.sched_params);
-	/* probe VFs */
-	igt_sriov_enable_driver_autoprobe(pf_fd);
-	for (int vf = 1; vf <= num_vfs; ++vf)
-		igt_sriov_bind_vf_drm_driver(pf_fd, vf);
-
-	/* init subm_set */
-	subm_set_alloc_data(set, num_vfs + 1 /*PF*/);
+	struct vf_config *vf_configs = NULL;
+	struct runtime_metrics *metrics = NULL;
+	uint64_t measurement_start_ns = 0;
+	uint64_t measurement_end_ns = 0;
+	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
+	unsigned int k = select_inflight_k(job_sched_params->duration_ms,
+					   opts->inflight, false);
+
+	igt_info("eq=%ums pt=%uus prio=%s duration=%ums repeats=%d inflight=%u num_functions=%zu job_timeout=%ums\n",
+		 job_sched_params->sched_params.exec_quantum_ms,
+		 job_sched_params->sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(job_sched_params->sched_params.priority),
+		 job_sched_params->duration_ms, job_sched_params->num_repeats,
+		 k, num_functions, job_timeout_ms);
+
+	subm_set_alloc_data(set, num_functions);
 	subm_set_init_sync_method(set, opts->sync_method);
+	vf_configs = calloc(set->ndata, sizeof(*vf_configs));
+	metrics = calloc(set->ndata, sizeof(*metrics));
+	igt_assert(vf_configs && metrics);
 
 	for (int n = 0; n < set->ndata; ++n) {
 		int vf_fd =
@@ -1144,94 +1132,145 @@ static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opt
 
 		igt_assert_fd(vf_fd);
 		set->data[n].opts = opts;
-		subm_init(&set->data[n].subm, vf_fd, vf_ids[n], 0,
-			  xe_engine(vf_fd, 0)->instance, k);
+		subm_init(&set->data[n].subm, vf_fd, vf_ids[n], 0, *eci, k);
 		subm_workload_init(&set->data[n].subm,
 				   &(struct subm_work_desc){
-					.duration_ms = job_sched_params.duration_ms,
+					.duration_ms = job_sched_params->duration_ms,
 					.preempt = true,
-					.repeats = job_sched_params.num_repeats });
+					.repeats = job_sched_params->num_repeats });
 		igt_stats_init_with_size(&set->data[n].stats.samples,
 					 set->data[n].subm.work.repeats);
 		set->data[n].stats.complete_ts = calloc(set->data[n].subm.work.repeats,
 							sizeof(uint64_t));
+		igt_assert(set->data[n].stats.complete_ts);
 		if (set->sync_method == SYNC_BARRIER)
 			set->data[n].barrier = &set->barrier;
 	}
 
-	/* dispatch spinners, wait for results */
-	subm_set_dispatch_and_wait_threads(set);
-	subm_set_close_handles(set);
+	run_subm_set_and_collect_metrics(pf_fd, set, vf_configs, metrics,
+					 verify_with_perf_counters,
+					 &measurement_start_ns,
+					 &measurement_end_ns);
 
-	/* verify results */
-	compute_common_time_frame_stats(set);
-	for (int n = 0; n < set->ndata; ++n) {
-		struct subm_stats *stats = &set->data[n].stats;
-		const double ref_rate = set->data[0].stats.concurrent_rate;
-
-		igt_assert_eq(0, stats->num_early_finish);
-		if (!check_within_epsilon(stats->concurrent_rate, ref_rate,
-					  opts->outlier_treshold)) {
-			log_sample_values(set->data[0].subm.id,
-					  &set->data[0].stats,
-					  set->data[0].stats.concurrent_mean,
-					  opts->outlier_treshold);
-			log_sample_values(set->data[n].subm.id, stats,
-					  set->data[0].stats.concurrent_mean,
-					  opts->outlier_treshold);
-			igt_assert_f(false,
-				     "Throughput=%.3f execs/s not within +-%.0f%% of expected=%.3f execs/s\n",
-				     stats->concurrent_rate,
-				     opts->outlier_treshold * 100, ref_rate);
-		}
+	for (int n = 0; n < set->ndata; ++n)
+		igt_assert_eq(0, set->data[n].stats.num_early_finish);
+
+	assert_share_matches_expected(metrics, set->ndata,
+				      opts->outlier_treshold, false);
+
+	if (verify_with_perf_counters) {
+		warn_active_ticks_mismatch(metrics, set->ndata,
+					   opts->outlier_treshold);
+		assert_share_matches_expected(metrics, set->ndata,
+					      opts->outlier_treshold, true);
+		assert_throughput_share_matches_total_tick(metrics,
+							   set->ndata,
+							   opts->outlier_treshold);
 	}
 
-	/* cleanup */
+	free(vf_configs);
+	free(metrics);
 	subm_set_fini(set);
-	__set_vfs_scheduling_params(pf_fd, num_vfs, &(struct vf_sched_params){});
-	xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
 }
 
 /**
- * SUBTEST: nonpreempt-engine-resets
+ * SUBTEST: equal-throughput-%s-priority
+ * Description:
+ *   Check all VFs with same scheduling settings running same workload
+ *   achieve the same throughput.
+ *
+ * arg[1]:
+ *
+ * @normal: normal
+ * @low: low
+ */
+static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opts,
+			     bool verify_with_perf_counters,
+			     struct job_sched_params *job_sched_params,
+			     enum xe_sriov_sched_priority priority,
+			     const struct drm_xe_engine_class_instance *eci)
+{
+	uint8_t vf_ids[num_vfs + 1 /*PF*/];
+
+	igt_assert(job_sched_params);
+
+	if (!job_sched_params->num_repeats) {
+		uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
+
+		*job_sched_params = prepare_job_sched_params(num_vfs + 1,
+							     job_timeout_ms,
+							     opts, priority);
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		set_vfs_scheduling_params(pf_fd, num_vfs,
+					  &job_sched_params->sched_params);
+		igt_sriov_enable_driver_autoprobe(pf_fd);
+		igt_sriov_enable_vfs(pf_fd, num_vfs);
+	}
+
+	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
+		    &(struct init_vf_ids_opts){ .shuffle = true,
+						.shuffle_pf = true });
+
+	verify_applied_scheduling_behavior(pf_fd, vf_ids, ARRAY_SIZE(vf_ids), opts,
+					   verify_with_perf_counters, eci,
+					   job_sched_params);
+}
+
+/**
+ * SUBTEST: nonpreempt-engine-resets-%s-priority
  * Description:
  *   Check all VFs running a non-preemptible workload with a duration
  *   exceeding the sum of its execution quantum and preemption timeout,
  *   will experience engine reset due to preemption timeout.
+ *
+ * arg[1]:
+ *
+ * @normal: normal
+ * @low: low
  */
 static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
-				     const struct subm_opts *opts)
+				     const struct subm_opts *opts,
+				     struct job_sched_params *job_sched_params,
+				     enum xe_sriov_sched_priority priority,
+				     const struct drm_xe_engine_class_instance *eci)
 {
 	struct subm_set set_ = {}, *set = &set_;
-	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
-	enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
-	struct vf_sched_params vf_sched_params = prepare_vf_sched_params(num_vfs, 1,
-									 job_timeout_ms, opts,
-									 priority);
-	uint64_t duration_ms = 2 * vf_sched_params.exec_quantum_ms +
-			       vf_sched_params.preempt_timeout_us / USEC_PER_MSEC;
+	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
 	int preemptible_end = 1;
 	uint8_t vf_ids[num_vfs + 1 /*PF*/];
-	const unsigned int k = select_inflight_k(duration_ms, opts->inflight, true);
+	unsigned int k;
 
-	igt_info("eq=%ums pt=%uus prio=%s duration=%" PRIu64 "ms inflight=%u num_vfs=%d job_timeout=%ums\n",
-		 vf_sched_params.exec_quantum_ms, vf_sched_params.preempt_timeout_us,
-		 xe_sriov_sched_priority_to_string(vf_sched_params.priority),
-		 duration_ms, k, num_vfs, job_timeout_ms);
+	igt_assert(job_sched_params);
+
+	if (!job_sched_params->num_repeats) {
+		struct vf_sched_params vf_sched_params = prepare_vf_sched_params(num_vfs, 1,
+										 job_timeout_ms,
+										 opts,
+										 priority);
+
+		*job_sched_params = (struct job_sched_params) {
+			.sched_params = vf_sched_params,
+			.duration_ms = 2 * vf_sched_params.exec_quantum_ms +
+				       vf_sched_params.preempt_timeout_us / USEC_PER_MSEC,
+			.num_repeats = 1,
+		};
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		set_vfs_scheduling_params(pf_fd, num_vfs,
+					  &job_sched_params->sched_params);
+		igt_sriov_enable_driver_autoprobe(pf_fd);
+		igt_sriov_enable_vfs(pf_fd, num_vfs);
+	}
+	k = select_inflight_k(job_sched_params->duration_ms, opts->inflight, true);
+
+	igt_info("eq=%ums pt=%uus prio=%s duration=%dms inflight=%u num_functions=%d job_timeout=%ums\n",
+		 job_sched_params->sched_params.exec_quantum_ms,
+		 job_sched_params->sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(job_sched_params->sched_params.priority),
+		 job_sched_params->duration_ms, k, num_vfs + 1, job_timeout_ms);
 
 	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
 		    &(struct init_vf_ids_opts){ .shuffle = true,
 						.shuffle_pf = true });
-	xe_sriov_require_default_scheduling_attributes(pf_fd);
-	/* enable VFs */
-	igt_sriov_disable_driver_autoprobe(pf_fd);
-	igt_sriov_enable_vfs(pf_fd, num_vfs);
-	/* set scheduling params (PF and VFs) */
-	set_vfs_scheduling_params(pf_fd, num_vfs, &vf_sched_params);
-	/* probe VFs */
-	igt_sriov_enable_driver_autoprobe(pf_fd);
-	for (int vf = 1; vf <= num_vfs; ++vf)
-		igt_sriov_bind_vf_drm_driver(pf_fd, vf);
 
 	/* init subm_set */
 	subm_set_alloc_data(set, num_vfs + 1 /*PF*/);
@@ -1246,10 +1285,10 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
 		igt_assert_fd(vf_fd);
 		set->data[n].opts = opts;
 		subm_init(&set->data[n].subm, vf_fd, vf_ids[n], 0,
-			  xe_engine(vf_fd, 0)->instance, k);
+			  *eci, k);
 		subm_workload_init(&set->data[n].subm,
 				   &(struct subm_work_desc){
-					.duration_ms = duration_ms,
+					.duration_ms = job_sched_params->duration_ms,
 					.preempt = (n < preemptible_end),
 					.repeats = MIN_NUM_REPEATS });
 		igt_stats_init_with_size(&set->data[n].stats.samples,
@@ -1277,8 +1316,20 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
 
 	/* cleanup */
 	subm_set_fini(set);
-	__set_vfs_scheduling_params(pf_fd, num_vfs, &(struct vf_sched_params){});
-	xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+}
+
+static bool skip_visited_gt(bool extended_scope, uint64_t *visited_gts,
+			    unsigned short gt_id)
+{
+	if (extended_scope)
+		return false;
+
+	if (*visited_gts & (1ULL << gt_id))
+		return true;
+
+	*visited_gts |= (1ULL << gt_id);
+
+	return false;
 }
 
 static struct subm_opts subm_opts = {
@@ -1350,6 +1401,9 @@ int igt_main_args("", long_opts, help_str, subm_opts_handler, NULL)
 {
 	int pf_fd;
 	bool autoprobe;
+	bool has_perf_events;
+	struct drm_xe_engine_class_instance *eci;
+	unsigned short ecls;
 
 	igt_fixture() {
 		pf_fd = drm_open_driver(DRIVER_XE);
@@ -1358,31 +1412,114 @@ int igt_main_args("", long_opts, help_str, subm_opts_handler, NULL)
 		igt_require(xe_sriov_admin_is_present(pf_fd));
 		autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
 		xe_sriov_require_default_scheduling_attributes(pf_fd);
+		xe_perf_device(pf_fd, perf_device, sizeof(perf_device));
+		has_perf_events = has_perf_event(perf_device, "engine-active-ticks") &&
+				  has_perf_event(perf_device, "engine-total-ticks");
 	}
 
-	igt_describe("Check VFs achieve equal throughput");
-	igt_subtest_with_dynamic("equal-throughput") {
-		if (extended_scope)
-			for_each_sriov_num_vfs(pf_fd, vf)
-				igt_dynamic_f("numvfs-%d", vf)
-					throughput_ratio(pf_fd, vf, &subm_opts);
+	for (enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
+	     priority <= XE_SRIOV_SCHED_PRIORITY_NORMAL;
+	     priority++) {
+		igt_describe_f("Check VFs achieve equal throughput with %s priority provisioning applied before VF enable on each selected engine",
+			       xe_sriov_sched_priority_to_string(priority));
+		igt_subtest_with_dynamic_f("equal-throughput-%s-priority",
+					   xe_sriov_sched_priority_to_string(priority)) {
+			if (extended_scope)
+				for_each_sriov_num_vfs(pf_fd, vf) {
+					struct job_sched_params job_sched_params = { };
+
+					xe_for_each_engine(pf_fd, eci) {
+						ecls = eci->engine_class;
+						igt_dynamic_f("numvfs-%d-gt%u-%s%u", vf,
+							      eci->gt_id,
+							      xe_engine_class_short_string(ecls),
+							      eci->engine_instance)
+							throughput_ratio(pf_fd, vf, &subm_opts,
+									 has_perf_events,
+									 &job_sched_params,
+									 priority, eci);
+					}
+				}
+
+			for_random_sriov_vf(pf_fd, vf) {
+				struct job_sched_params job_sched_params = { };
+				uint64_t visited_gts = 0;
+
+				xe_for_each_engine(pf_fd, eci) {
+					if (skip_visited_gt(extended_scope, &visited_gts,
+							    eci->gt_id))
+						continue;
+
+					ecls = eci->engine_class;
+					igt_dynamic_f("numvfs-random-gt%u-%s%u",
+						      eci->gt_id,
+						      xe_engine_class_short_string(ecls),
+						      eci->engine_instance)
+						throughput_ratio(pf_fd, vf, &subm_opts,
+								 has_perf_events,
+								 &job_sched_params,
+								 priority, eci);
+				}
+			}
+		}
 
-		for_random_sriov_vf(pf_fd, vf)
-			igt_dynamic("numvfs-random")
-				throughput_ratio(pf_fd, vf, &subm_opts);
+		igt_fixture() {
+			__set_vfs_scheduling_params(pf_fd, igt_sriov_get_total_vfs(pf_fd),
+						    &(struct vf_sched_params){});
+			xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		}
 	}
 
-	igt_describe("Check VFs experience engine reset due to preemption timeout");
-	igt_subtest_with_dynamic("nonpreempt-engine-resets") {
-		if (extended_scope)
-			for_each_sriov_num_vfs(pf_fd, vf)
-				igt_dynamic_f("numvfs-%d", vf)
-					nonpreempt_engine_resets(pf_fd, vf,
-								 &subm_opts);
-
-		for_random_sriov_vf(pf_fd, vf)
-			igt_dynamic("numvfs-random")
-				nonpreempt_engine_resets(pf_fd, vf, &subm_opts);
+	for (enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
+	     priority <= XE_SRIOV_SCHED_PRIORITY_NORMAL;
+	     priority++) {
+		igt_describe("Check VFs experience engine reset due to preemption timeout on each selected engine");
+		igt_subtest_with_dynamic_f("nonpreempt-engine-resets-%s-priority",
+					   xe_sriov_sched_priority_to_string(priority)) {
+			if (extended_scope)
+				for_each_sriov_num_vfs(pf_fd, vf) {
+					struct job_sched_params job_sched_params = { };
+
+					xe_for_each_engine(pf_fd, eci) {
+						ecls = eci->engine_class;
+						igt_dynamic_f("numvfs-%d-gt%u-%s%u", vf,
+							      eci->gt_id,
+							      xe_engine_class_short_string(ecls),
+							      eci->engine_instance)
+							nonpreempt_engine_resets(pf_fd, vf,
+										 &subm_opts,
+										 &job_sched_params,
+										 priority,
+										 eci);
+					}
+				}
+
+			for_random_sriov_vf(pf_fd, vf) {
+				struct job_sched_params job_sched_params = { };
+				uint64_t visited_gts = 0;
+
+				xe_for_each_engine(pf_fd, eci) {
+					if (skip_visited_gt(extended_scope, &visited_gts,
+							    eci->gt_id))
+						continue;
+
+					ecls = eci->engine_class;
+					igt_dynamic_f("numvfs-random-gt%u-%s%u",
+						      eci->gt_id,
+						      xe_engine_class_short_string(ecls),
+						      eci->engine_instance)
+						nonpreempt_engine_resets(pf_fd, vf, &subm_opts,
+									 &job_sched_params,
+									 priority, eci);
+				}
+			}
+		}
+
+		igt_fixture() {
+			__set_vfs_scheduling_params(pf_fd, igt_sriov_get_total_vfs(pf_fd),
+						    &(struct vf_sched_params){});
+			xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		}
 	}
 
 	igt_fixture() {
Signature · 1 line
2.43.0
Reviewed-by on v1 6/8
#13 lore raw

Re: [PATCH i-g-t 6/8] tests/intel/xe_sriov_scheduling: Refactor throughput_ratio and nonpreempt-engine-resets test

Quoted 6 lines · Marcin Bernatowicz

Extract verify_applied_scheduling_behavior so equal-throughput and default-enabled-fair-scheduling share common verification logic.

Increase coverage with verification across all GTs and both low/normal scheduling priorities.

Quoted 7 lines

Strengthen confidence in results with PMU-based checks using engine-active-ticks and engine-total-ticks metrics (when available).

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 473 lines
---
  tests/intel/xe_sriov_scheduling.c | 373 ++++++++++++++++++++----------
  1 file changed, 255 insertions(+), 118 deletions(-)
tests/intel/xe_sriov_scheduling.c +255 -118
index 9550c8e58..692f92e76 100644
@@ -158,6 +158,7 @@ static void subm_fini(struct subm *s)
  static void subm_workload_init(struct subm *s, struct subm_work_desc *work)
  {
  	s->work = *work;
+
  	s->expected_ticks = xe_spin_nsec_to_ticks(s->fd, s->hwe.gt_id,
  						  s->work.duration_ms * 1000000);
  	for (unsigned int i = 0; i < s->slots; i++)
@@ -1093,48 +1094,35 @@ static void warn_active_ticks_mismatch(const struct runtime_metrics *metrics,
  	}
  }
 
-/**
- * SUBTEST: equal-throughput
- * Description:
- *   Check all VFs with same scheduling settings running same workload
- *   achieve the same throughput.
- */
-static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opts)
+static void verify_applied_scheduling_behavior(int pf_fd,
+					       const uint8_t *vf_ids,
+					       size_t num_functions,
+					       const struct subm_opts *opts,
+					       bool verify_with_perf_counters,
+					       const struct drm_xe_engine_class_instance *eci,
+					       const struct job_sched_params *job_sched_params)
  {
  	struct subm_set set_ = {}, *set = &set_;
-	uint8_t vf_ids[num_vfs + 1 /*PF*/];
-	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
-	struct job_sched_params job_sched_params = prepare_job_sched_params(num_vfs + 1,
-									    job_timeout_ms,
-								    opts,
-								    XE_SRIOV_SCHED_PRIORITY_LOW);
-	const unsigned int k = select_inflight_k(job_sched_params.duration_ms,
-						 opts->inflight, false);
-
-	igt_info("eq=%ums pt=%uus prio=%s duration=%ums repeats=%d inflight=%u num_vfs=%d job_timeout=%ums\n",
-		 job_sched_params.sched_params.exec_quantum_ms,
-		 job_sched_params.sched_params.preempt_timeout_us,
-		 xe_sriov_sched_priority_to_string(job_sched_params.sched_params.priority),
-		 job_sched_params.duration_ms, job_sched_params.num_repeats,
-		 k, num_vfs + 1, job_timeout_ms);
-
-	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
-		    &(struct init_vf_ids_opts){ .shuffle = true,
-						.shuffle_pf = true });
-	xe_sriov_require_default_scheduling_attributes(pf_fd);
-	/* enable VFs */
-	igt_sriov_disable_driver_autoprobe(pf_fd);
-	igt_sriov_enable_vfs(pf_fd, num_vfs);
-	/* set scheduling params (PF and VFs) */
-	set_vfs_scheduling_params(pf_fd, num_vfs, &job_sched_params.sched_params);
-	/* probe VFs */
-	igt_sriov_enable_driver_autoprobe(pf_fd);
-	for (int vf = 1; vf <= num_vfs; ++vf)
-		igt_sriov_bind_vf_drm_driver(pf_fd, vf);
-
-	/* init subm_set */
-	subm_set_alloc_data(set, num_vfs + 1 /*PF*/);
+	struct vf_config *vf_configs = NULL;
+	struct runtime_metrics *metrics = NULL;
+	uint64_t measurement_start_ns = 0;
+	uint64_t measurement_end_ns = 0;
+	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
+	unsigned int k = select_inflight_k(job_sched_params->duration_ms,
+					   opts->inflight, false);
+
+	igt_info("eq=%ums pt=%uus prio=%s duration=%ums repeats=%d inflight=%u num_functions=%zu job_timeout=%ums\n",
+		 job_sched_params->sched_params.exec_quantum_ms,
+		 job_sched_params->sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(job_sched_params->sched_params.priority),
+		 job_sched_params->duration_ms, job_sched_params->num_repeats,
+		 k, num_functions, job_timeout_ms);
+
+	subm_set_alloc_data(set, num_functions);
  	subm_set_init_sync_method(set, opts->sync_method);
+	vf_configs = calloc(set->ndata, sizeof(*vf_configs));
+	metrics = calloc(set->ndata, sizeof(*metrics));
+	igt_assert(vf_configs && metrics);
 
  	for (int n = 0; n < set->ndata; ++n) {
  		int vf_fd =
@@ -1144,94 +1132,145 @@ static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opt
 
  		igt_assert_fd(vf_fd);
  		set->data[n].opts = opts;
-		subm_init(&set->data[n].subm, vf_fd, vf_ids[n], 0,
-			  xe_engine(vf_fd, 0)->instance, k);
+		subm_init(&set->data[n].subm, vf_fd, vf_ids[n], 0, *eci, k);
  		subm_workload_init(&set->data[n].subm,
  				   &(struct subm_work_desc){
-					.duration_ms = job_sched_params.duration_ms,
+					.duration_ms = job_sched_params->duration_ms,
  					.preempt = true,
-					.repeats = job_sched_params.num_repeats });
+					.repeats = job_sched_params->num_repeats });
  		igt_stats_init_with_size(&set->data[n].stats.samples,
  					 set->data[n].subm.work.repeats);
  		set->data[n].stats.complete_ts = calloc(set->data[n].subm.work.repeats,
  							sizeof(uint64_t));
+		igt_assert(set->data[n].stats.complete_ts);
  		if (set->sync_method == SYNC_BARRIER)
  			set->data[n].barrier = &set->barrier;
  	}
 
-	/* dispatch spinners, wait for results */
-	subm_set_dispatch_and_wait_threads(set);
-	subm_set_close_handles(set);
+	run_subm_set_and_collect_metrics(pf_fd, set, vf_configs, metrics,
+					 verify_with_perf_counters,
+					 &measurement_start_ns,
+					 &measurement_end_ns);
 
-	/* verify results */
-	compute_common_time_frame_stats(set);
-	for (int n = 0; n < set->ndata; ++n) {
-		struct subm_stats *stats = &set->data[n].stats;
-		const double ref_rate = set->data[0].stats.concurrent_rate;
-
-		igt_assert_eq(0, stats->num_early_finish);
-		if (!check_within_epsilon(stats->concurrent_rate, ref_rate,
-					  opts->outlier_treshold)) {
-			log_sample_values(set->data[0].subm.id,
-					  &set->data[0].stats,
-					  set->data[0].stats.concurrent_mean,
-					  opts->outlier_treshold);
-			log_sample_values(set->data[n].subm.id, stats,
-					  set->data[0].stats.concurrent_mean,
-					  opts->outlier_treshold);
-			igt_assert_f(false,
-				     "Throughput=%.3f execs/s not within +-%.0f%% of expected=%.3f execs/s\n",
-				     stats->concurrent_rate,
-				     opts->outlier_treshold * 100, ref_rate);
-		}
+	for (int n = 0; n < set->ndata; ++n)
+		igt_assert_eq(0, set->data[n].stats.num_early_finish);
+
+	assert_share_matches_expected(metrics, set->ndata,
+				      opts->outlier_treshold, false);
+
+	if (verify_with_perf_counters) {
+		warn_active_ticks_mismatch(metrics, set->ndata,
+					   opts->outlier_treshold);
+		assert_share_matches_expected(metrics, set->ndata,
+					      opts->outlier_treshold, true);
+		assert_throughput_share_matches_total_tick(metrics,
+							   set->ndata,
+							   opts->outlier_treshold);
  	}
 
-	/* cleanup */
+	free(vf_configs);
+	free(metrics);
  	subm_set_fini(set);
-	__set_vfs_scheduling_params(pf_fd, num_vfs, &(struct vf_sched_params){});
-	xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
  }
 
  /**
- * SUBTEST: nonpreempt-engine-resets
+ * SUBTEST: equal-throughput-%s-priority
+ * Description:
+ *   Check all VFs with same scheduling settings running same workload
+ *   achieve the same throughput.
+ *
+ * arg[1]:
+ *
+ * @normal: normal
+ * @low: low
+ */
+static void throughput_ratio(int pf_fd, int num_vfs, const struct subm_opts *opts,
+			     bool verify_with_perf_counters,
+			     struct job_sched_params *job_sched_params,
+			     enum xe_sriov_sched_priority priority,
+			     const struct drm_xe_engine_class_instance *eci)
+{
+	uint8_t vf_ids[num_vfs + 1 /*PF*/];
+
+	igt_assert(job_sched_params);
+
+	if (!job_sched_params->num_repeats) {
+		uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
+
+		*job_sched_params = prepare_job_sched_params(num_vfs + 1,
+							     job_timeout_ms,
+							     opts, priority);
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		set_vfs_scheduling_params(pf_fd, num_vfs,
+					  &job_sched_params->sched_params);
+		igt_sriov_enable_driver_autoprobe(pf_fd);
+		igt_sriov_enable_vfs(pf_fd, num_vfs);
+	}
+
+	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
+		    &(struct init_vf_ids_opts){ .shuffle = true,
+						.shuffle_pf = true });
+
+	verify_applied_scheduling_behavior(pf_fd, vf_ids, ARRAY_SIZE(vf_ids), opts,
+					   verify_with_perf_counters, eci,
+					   job_sched_params);
+}
+
+/**
+ * SUBTEST: nonpreempt-engine-resets-%s-priority
   * Description:
   *   Check all VFs running a non-preemptible workload with a duration
   *   exceeding the sum of its execution quantum and preemption timeout,
   *   will experience engine reset due to preemption timeout.
+ *
+ * arg[1]:
+ *
+ * @normal: normal
+ * @low: low
   */
  static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
-				     const struct subm_opts *opts)
+				     const struct subm_opts *opts,
+				     struct job_sched_params *job_sched_params,
+				     enum xe_sriov_sched_priority priority,
+				     const struct drm_xe_engine_class_instance *eci)
  {
  	struct subm_set set_ = {}, *set = &set_;
-	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, &xe_engine(pf_fd, 0)->instance);
-	enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
-	struct vf_sched_params vf_sched_params = prepare_vf_sched_params(num_vfs, 1,
-									 job_timeout_ms, opts,
-									 priority);
-	uint64_t duration_ms = 2 * vf_sched_params.exec_quantum_ms +
-			       vf_sched_params.preempt_timeout_us / USEC_PER_MSEC;
+	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
  	int preemptible_end = 1;
  	uint8_t vf_ids[num_vfs + 1 /*PF*/];
-	const unsigned int k = select_inflight_k(duration_ms, opts->inflight, true);
+	unsigned int k;
 
-	igt_info("eq=%ums pt=%uus prio=%s duration=%" PRIu64 "ms inflight=%u num_vfs=%d job_timeout=%ums\n",
-		 vf_sched_params.exec_quantum_ms, vf_sched_params.preempt_timeout_us,
-		 xe_sriov_sched_priority_to_string(vf_sched_params.priority),
-		 duration_ms, k, num_vfs, job_timeout_ms);
+	igt_assert(job_sched_params);
+
+	if (!job_sched_params->num_repeats) {
+		struct vf_sched_params vf_sched_params = prepare_vf_sched_params(num_vfs, 1,
+										 job_timeout_ms,
+										 opts,
+										 priority);
+
+		*job_sched_params = (struct job_sched_params) {
+			.sched_params = vf_sched_params,
+			.duration_ms = 2 * vf_sched_params.exec_quantum_ms +
+				       vf_sched_params.preempt_timeout_us / USEC_PER_MSEC,
+			.num_repeats = 1,
+		};
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		set_vfs_scheduling_params(pf_fd, num_vfs,
+					  &job_sched_params->sched_params);
+		igt_sriov_enable_driver_autoprobe(pf_fd);
+		igt_sriov_enable_vfs(pf_fd, num_vfs);
+	}
+	k = select_inflight_k(job_sched_params->duration_ms, opts->inflight, true);
+
+	igt_info("eq=%ums pt=%uus prio=%s duration=%dms inflight=%u num_functions=%d job_timeout=%ums\n",
+		 job_sched_params->sched_params.exec_quantum_ms,
+		 job_sched_params->sched_params.preempt_timeout_us,
+		 xe_sriov_sched_priority_to_string(job_sched_params->sched_params.priority),
+		 job_sched_params->duration_ms, k, num_vfs + 1, job_timeout_ms);
 
  	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
  		    &(struct init_vf_ids_opts){ .shuffle = true,
  						.shuffle_pf = true });
-	xe_sriov_require_default_scheduling_attributes(pf_fd);
-	/* enable VFs */
-	igt_sriov_disable_driver_autoprobe(pf_fd);
-	igt_sriov_enable_vfs(pf_fd, num_vfs);
-	/* set scheduling params (PF and VFs) */
-	set_vfs_scheduling_params(pf_fd, num_vfs, &vf_sched_params);
-	/* probe VFs */
-	igt_sriov_enable_driver_autoprobe(pf_fd);
-	for (int vf = 1; vf <= num_vfs; ++vf)
-		igt_sriov_bind_vf_drm_driver(pf_fd, vf);
 
  	/* init subm_set */
  	subm_set_alloc_data(set, num_vfs + 1 /*PF*/);
@@ -1246,10 +1285,10 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
  		igt_assert_fd(vf_fd);
  		set->data[n].opts = opts;
  		subm_init(&set->data[n].subm, vf_fd, vf_ids[n], 0,
-			  xe_engine(vf_fd, 0)->instance, k);
+			  *eci, k);
  		subm_workload_init(&set->data[n].subm,
  				   &(struct subm_work_desc){
-					.duration_ms = duration_ms,
+					.duration_ms = job_sched_params->duration_ms,
  					.preempt = (n < preemptible_end),
  					.repeats = MIN_NUM_REPEATS });
  		igt_stats_init_with_size(&set->data[n].stats.samples,
@@ -1277,8 +1316,20 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
 
  	/* cleanup */
  	subm_set_fini(set);
-	__set_vfs_scheduling_params(pf_fd, num_vfs, &(struct vf_sched_params){});
-	xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+}
+
+static bool skip_visited_gt(bool extended_scope, uint64_t *visited_gts,
+			    unsigned short gt_id)
+{
+	if (extended_scope)
+		return false;
+
+	if (*visited_gts & (1ULL << gt_id))
+		return true;
+
+	*visited_gts |= (1ULL << gt_id);
+
+	return false;
  }
 
  static struct subm_opts subm_opts = {
@@ -1350,6 +1401,9 @@ int igt_main_args("", long_opts, help_str, subm_opts_handler, NULL)
  {
  	int pf_fd;
  	bool autoprobe;
+	bool has_perf_events;
+	struct drm_xe_engine_class_instance *eci;
+	unsigned short ecls;
 
  	igt_fixture() {
  		pf_fd = drm_open_driver(DRIVER_XE);
@@ -1358,31 +1412,114 @@ int igt_main_args("", long_opts, help_str, subm_opts_handler, NULL)
  		igt_require(xe_sriov_admin_is_present(pf_fd));
  		autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
  		xe_sriov_require_default_scheduling_attributes(pf_fd);
+		xe_perf_device(pf_fd, perf_device, sizeof(perf_device));
+		has_perf_events = has_perf_event(perf_device, "engine-active-ticks") &&
+				  has_perf_event(perf_device, "engine-total-ticks");
  	}
 
-	igt_describe("Check VFs achieve equal throughput");
-	igt_subtest_with_dynamic("equal-throughput") {
-		if (extended_scope)
-			for_each_sriov_num_vfs(pf_fd, vf)
-				igt_dynamic_f("numvfs-%d", vf)
-					throughput_ratio(pf_fd, vf, &subm_opts);
+	for (enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
+	     priority <= XE_SRIOV_SCHED_PRIORITY_NORMAL;
+	     priority++) {
+		igt_describe_f("Check VFs achieve equal throughput with %s priority provisioning applied before VF enable on each selected engine",
+			       xe_sriov_sched_priority_to_string(priority));
+		igt_subtest_with_dynamic_f("equal-throughput-%s-priority",
+					   xe_sriov_sched_priority_to_string(priority)) {
+			if (extended_scope)
+				for_each_sriov_num_vfs(pf_fd, vf) {
+					struct job_sched_params job_sched_params = { };
+
+					xe_for_each_engine(pf_fd, eci) {
+						ecls = eci->engine_class;
+						igt_dynamic_f("numvfs-%d-gt%u-%s%u", vf,
+							      eci->gt_id,
+							      xe_engine_class_short_string(ecls),
+							      eci->engine_instance)
+							throughput_ratio(pf_fd, vf, &subm_opts,
+									 has_perf_events,
+									 &job_sched_params,
+									 priority, eci);
+					}
+				}
+
+			for_random_sriov_vf(pf_fd, vf) {
+				struct job_sched_params job_sched_params = { };
+				uint64_t visited_gts = 0;
+
+				xe_for_each_engine(pf_fd, eci) {
+					if (skip_visited_gt(extended_scope, &visited_gts,
+							    eci->gt_id))
+						continue;
+
+					ecls = eci->engine_class;
+					igt_dynamic_f("numvfs-random-gt%u-%s%u",
+						      eci->gt_id,
+						      xe_engine_class_short_string(ecls),
+						      eci->engine_instance)
+						throughput_ratio(pf_fd, vf, &subm_opts,
+								 has_perf_events,
+								 &job_sched_params,
+								 priority, eci);
+				}
+			}
+		}
 
-		for_random_sriov_vf(pf_fd, vf)
-			igt_dynamic("numvfs-random")
-				throughput_ratio(pf_fd, vf, &subm_opts);
+		igt_fixture() {
+			__set_vfs_scheduling_params(pf_fd, igt_sriov_get_total_vfs(pf_fd),
+						    &(struct vf_sched_params){});
+			xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		}
  	}
 
-	igt_describe("Check VFs experience engine reset due to preemption timeout");
-	igt_subtest_with_dynamic("nonpreempt-engine-resets") {
-		if (extended_scope)
-			for_each_sriov_num_vfs(pf_fd, vf)
-				igt_dynamic_f("numvfs-%d", vf)
-					nonpreempt_engine_resets(pf_fd, vf,
-								 &subm_opts);
-
-		for_random_sriov_vf(pf_fd, vf)
-			igt_dynamic("numvfs-random")
-				nonpreempt_engine_resets(pf_fd, vf, &subm_opts);
+	for (enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
+	     priority <= XE_SRIOV_SCHED_PRIORITY_NORMAL;
+	     priority++) {
+		igt_describe("Check VFs experience engine reset due to preemption timeout on each selected engine");
+		igt_subtest_with_dynamic_f("nonpreempt-engine-resets-%s-priority",
+					   xe_sriov_sched_priority_to_string(priority)) {
+			if (extended_scope)
+				for_each_sriov_num_vfs(pf_fd, vf) {
+					struct job_sched_params job_sched_params = { };
+
+					xe_for_each_engine(pf_fd, eci) {
+						ecls = eci->engine_class;
+						igt_dynamic_f("numvfs-%d-gt%u-%s%u", vf,
+							      eci->gt_id,
+							      xe_engine_class_short_string(ecls),
+							      eci->engine_instance)
+							nonpreempt_engine_resets(pf_fd, vf,
+										 &subm_opts,
+										 &job_sched_params,
+										 priority,
+										 eci);
+					}
+				}
+
+			for_random_sriov_vf(pf_fd, vf) {
+				struct job_sched_params job_sched_params = { };
+				uint64_t visited_gts = 0;
+
+				xe_for_each_engine(pf_fd, eci) {
+					if (skip_visited_gt(extended_scope, &visited_gts,
+							    eci->gt_id))
+						continue;
+
+					ecls = eci->engine_class;
+					igt_dynamic_f("numvfs-random-gt%u-%s%u",
+						      eci->gt_id,
+						      xe_engine_class_short_string(ecls),
+						      eci->engine_instance)
+						nonpreempt_engine_resets(pf_fd, vf, &subm_opts,
+									 &job_sched_params,
+									 priority, eci);
+				}
+			}
+		}
+
+		igt_fixture() {
+			__set_vfs_scheduling_params(pf_fd, igt_sriov_get_total_vfs(pf_fd),
+						    &(struct vf_sched_params){});
+			xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		}
  	}
 
  	igt_fixture() {
#14 lore raw

PATCH 7/8 tests/intel/xe_sriov_scheduling: Remove unused log_sample_values helper

In reply to Marcin Bernatowicz

Drop the unused sample logging helper after the throughput verification path stopped relying on the detailed mismatch dump.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 47 -------------------------------
 1 file changed, 47 deletions(-)
tests/intel/xe_sriov_scheduling.c +0 -47
index 692f92e76..915442380 100644
@@ -472,53 +472,6 @@ static void compute_common_time_frame_stats(struct subm_set *set)
 	}
 }
 
-static void log_sample_values(char *id, struct subm_stats *stats,
-			      double comparison_mean, double outlier_treshold)
-{
-	const uint64_t *values = stats->samples.values_u64;
-	unsigned int n = stats->samples.n_values;
-	char buffer[2048];
-	char *p = buffer, *pend = buffer + sizeof(buffer);
-	unsigned int i;
-	const unsigned int edge_items = 3;
-	bool is_outlier;
-	double tolerance = outlier_treshold * comparison_mean;
-
-	p += snprintf(p, pend - p,
-		      "[%s] start=%f end=%f nsamples=%u comparison_mean=%.2fms\n",
-		      id, stats->start_timestamp * 1e-9, stats->end_timestamp * 1e-9, n,
-		      comparison_mean * 1e-6);
-
-	for (i = 0; i < n && p < pend; ++i) {
-		is_outlier = fabs(values[i] - comparison_mean) > tolerance;
-
-		if (n <= 2 * edge_items || i < edge_items ||
-		    i >= n - edge_items || is_outlier) {
-			if (is_outlier) {
-				double pct_diff =
-					100 *
-					(comparison_mean ?
-						 (values[i] - comparison_mean) /
-							 comparison_mean :
-						 1.0);
-
-				p += snprintf(p, pend - p,
-					      "%0.2f @%d Pct Diff %0.2f%%\n",
-					      values[i] * 1e-6, i,
-					      pct_diff);
-			} else {
-				p += snprintf(p, pend - p, "%0.2f\n",
-					      values[i] * 1e-6);
-			}
-		}
-
-		if (i == edge_items && n > 2 * edge_items)
-			p += snprintf(p, pend - p, "...\n");
-	}
-
-	igt_debug("%s\n", buffer);
-}
-
 #define MIN_NUM_REPEATS 25
 #define MIN_EXEC_QUANTUM_MS 2
 #define MAX_EXEC_QUANTUM_MS 32
Signature · 1 line
2.43.0
Reviewed-by on v1 7/8
#15 lore raw

Re: [PATCH i-g-t 7/8] tests/intel/xe_sriov_scheduling: Remove unused log_sample_values helper

Quoted 7 lines · Marcin Bernatowicz

Drop the unused sample logging helper after the throughput verification path stopped relying on the detailed mismatch dump.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 62 lines
---
  tests/intel/xe_sriov_scheduling.c | 47 -------------------------------
  1 file changed, 47 deletions(-)
tests/intel/xe_sriov_scheduling.c +0 -47
index 692f92e76..915442380 100644
@@ -472,53 +472,6 @@ static void compute_common_time_frame_stats(struct subm_set *set)
  	}
  }
 
-static void log_sample_values(char *id, struct subm_stats *stats,
-			      double comparison_mean, double outlier_treshold)
-{
-	const uint64_t *values = stats->samples.values_u64;
-	unsigned int n = stats->samples.n_values;
-	char buffer[2048];
-	char *p = buffer, *pend = buffer + sizeof(buffer);
-	unsigned int i;
-	const unsigned int edge_items = 3;
-	bool is_outlier;
-	double tolerance = outlier_treshold * comparison_mean;
-
-	p += snprintf(p, pend - p,
-		      "[%s] start=%f end=%f nsamples=%u comparison_mean=%.2fms\n",
-		      id, stats->start_timestamp * 1e-9, stats->end_timestamp * 1e-9, n,
-		      comparison_mean * 1e-6);
-
-	for (i = 0; i < n && p < pend; ++i) {
-		is_outlier = fabs(values[i] - comparison_mean) > tolerance;
-
-		if (n <= 2 * edge_items || i < edge_items ||
-		    i >= n - edge_items || is_outlier) {
-			if (is_outlier) {
-				double pct_diff =
-					100 *
-					(comparison_mean ?
-						 (values[i] - comparison_mean) /
-							 comparison_mean :
-						 1.0);
-
-				p += snprintf(p, pend - p,
-					      "%0.2f @%d Pct Diff %0.2f%%\n",
-					      values[i] * 1e-6, i,
-					      pct_diff);
-			} else {
-				p += snprintf(p, pend - p, "%0.2f\n",
-					      values[i] * 1e-6);
-			}
-		}
-
-		if (i == edge_items && n > 2 * edge_items)
-			p += snprintf(p, pend - p, "...\n");
-	}
-
-	igt_debug("%s\n", buffer);
-}
-
  #define MIN_NUM_REPEATS 25
  #define MIN_EXEC_QUANTUM_MS 2
  #define MAX_EXEC_QUANTUM_MS 32
#16 lore raw

PATCH 8/8 tests/intel/xe_sriov_scheduling: Add default fair scheduling test

In reply to Marcin Bernatowicz

Verify PF and enabled VFs keep a fair share with the driver-applied default scheduling settings, without overriding scheduling parameters.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
---
 tests/intel/xe_sriov_scheduling.c | 145 ++++++++++++++++++++++++++++++
 1 file changed, 145 insertions(+)
tests/intel/xe_sriov_scheduling.c +145 -0
index 915442380..aa3e5fccc 100644
@@ -1271,6 +1271,112 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
 	subm_set_fini(set);
 }
 
+static struct job_sched_params
+prepare_default_enabled_job_sched_params(int pf_fd,
+					 const uint8_t *vf_ids,
+					 size_t num_functions,
+					 int job_timeout_ms)
+{
+	struct job_sched_params params = { };
+	uint32_t min_exec_quantum_ms = UINT32_MAX;
+
+	params.sched_params = (struct vf_sched_params) {
+		.exec_quantum_ms = xe_sriov_admin_get_exec_quantum_ms(pf_fd, vf_ids[0]),
+		.preempt_timeout_us = xe_sriov_admin_get_preempt_timeout_us(pf_fd, vf_ids[0]),
+		.priority = xe_sriov_admin_get_sched_priority(pf_fd, vf_ids[0], NULL),
+	};
+
+	for (size_t n = 0; n < num_functions; ++n) {
+		uint32_t exec_quantum_ms =
+			xe_sriov_admin_get_exec_quantum_ms(pf_fd, vf_ids[n]);
+
+		min_exec_quantum_ms = min(min_exec_quantum_ms,
+					  exec_quantum_ms);
+	}
+
+	params.duration_ms = calculate_job_duration_ms(min_exec_quantum_ms);
+	params.num_repeats = adjust_num_repeats(params.duration_ms, num_functions);
+
+	igt_require_f(params.duration_ms +
+		      (num_functions - 1) * params.sched_params.exec_quantum_ms <=
+		      job_timeout_ms,
+		      "Default scheduling eq=%ums across %zu functions exceeds job timeout=%dms\n",
+		      params.sched_params.exec_quantum_ms, num_functions, job_timeout_ms);
+
+	return params;
+}
+
+static void validate_default_enabled_sched_params(int pf_fd,
+						  const uint8_t *vf_ids,
+						  size_t num_functions)
+{
+	for (size_t n = 0; n < num_functions; ++n) {
+		uint32_t exec_quantum_ms =
+			xe_sriov_admin_get_exec_quantum_ms(pf_fd, vf_ids[n]);
+		uint32_t preempt_timeout_us =
+			xe_sriov_admin_get_preempt_timeout_us(pf_fd, vf_ids[n]);
+		enum xe_sriov_sched_priority priority =
+			xe_sriov_admin_get_sched_priority(pf_fd, vf_ids[n], NULL);
+
+		igt_require_f(exec_quantum_ms > 0,
+			      "%s exec_quantum_ms stayed at 0 after enabling VFs\n",
+			      igt_sriov_func_str(vf_ids[n]));
+		igt_require_f(preempt_timeout_us > 0,
+			      "%s preempt_timeout_us stayed at 0 after enabling VFs\n",
+			      igt_sriov_func_str(vf_ids[n]));
+		igt_warn_on_f(priority != XE_SRIOV_SCHED_PRIORITY_LOW,
+			      "%s expected LOW sched_priority after enabling VFs, got %s\n",
+			      igt_sriov_func_str(vf_ids[n]),
+			      xe_sriov_sched_priority_to_string(priority));
+	}
+}
+
+static void ensure_enabled_vfs(int pf_fd, int num_vfs)
+{
+	unsigned int enabled_vfs = igt_sriov_get_enabled_vfs(pf_fd);
+
+	if (enabled_vfs && enabled_vfs != (unsigned int)num_vfs) {
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		enabled_vfs = 0;
+	}
+
+	if (!enabled_vfs) {
+		xe_sriov_require_default_scheduling_attributes(pf_fd);
+		igt_sriov_enable_driver_autoprobe(pf_fd);
+		igt_sriov_enable_vfs(pf_fd, num_vfs);
+	}
+}
+
+/**
+ * SUBTEST: default-enabled-fair-scheduling
+ * Description:
+ *   Check PF and enabled VFs keep fair scheduling using the driver-applied
+ *   default scheduling settings established when VFs are enabled.
+ */
+static void default_enabled_fair_scheduling(int pf_fd, int num_vfs,
+					    const struct subm_opts *opts,
+					    bool verify_with_perf_counters,
+					    const struct drm_xe_engine_class_instance *eci)
+{
+	uint8_t vf_ids[num_vfs + 1 /*PF*/];
+	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
+	struct job_sched_params job_sched_params;
+
+	ensure_enabled_vfs(pf_fd, num_vfs);
+
+	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
+		    &(struct init_vf_ids_opts){ .shuffle = true,
+						.shuffle_pf = true });
+	validate_default_enabled_sched_params(pf_fd, vf_ids, ARRAY_SIZE(vf_ids));
+	job_sched_params = prepare_default_enabled_job_sched_params(pf_fd, vf_ids,
+								    ARRAY_SIZE(vf_ids),
+								    job_timeout_ms);
+
+	verify_applied_scheduling_behavior(pf_fd, vf_ids, ARRAY_SIZE(vf_ids), opts,
+					   verify_with_perf_counters, eci,
+					   &job_sched_params);
+}
+
 static bool skip_visited_gt(bool extended_scope, uint64_t *visited_gts,
 			    unsigned short gt_id)
 {
@@ -1370,6 +1476,45 @@ int igt_main_args("", long_opts, help_str, subm_opts_handler, NULL)
 				  has_perf_event(perf_device, "engine-total-ticks");
 	}
 
+	igt_describe("Check PF and VFs keep fair scheduling using driver defaults applied on VF enable");
+	igt_subtest_with_dynamic("default-enabled-fair-scheduling") {
+		if (extended_scope)
+			for_each_sriov_num_vfs(pf_fd, vf)
+				xe_for_each_engine(pf_fd, eci) {
+					ecls = eci->engine_class;
+					igt_dynamic_f("numvfs-%d-gt%u-%s%u", vf,
+						      eci->gt_id,
+						      xe_engine_class_short_string(ecls),
+						      eci->engine_instance)
+						default_enabled_fair_scheduling(pf_fd, vf,
+										&subm_opts,
+										has_perf_events,
+										eci);
+				}
+
+		for_random_sriov_vf(pf_fd, vf) {
+			uint64_t visited_gts = 0;
+
+			xe_for_each_engine(pf_fd, eci) {
+				if (skip_visited_gt(extended_scope, &visited_gts,
+						    eci->gt_id))
+					continue;
+
+				igt_dynamic_f("numvfs-random-gt%u-%s%u",
+					      eci->gt_id,
+					      xe_engine_class_short_string(eci->engine_class),
+					      eci->engine_instance)
+					default_enabled_fair_scheduling(pf_fd, vf, &subm_opts,
+									has_perf_events,
+									eci);
+			}
+		}
+	}
+
+	igt_fixture() {
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+	}
+
 	for (enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
 	     priority <= XE_SRIOV_SCHED_PRIORITY_NORMAL;
 	     priority++) {
Signature · 1 line
2.43.0
Reviewed-by on v1 8/8
#17 lore raw

Re: [PATCH i-g-t 8/8] tests/intel/xe_sriov_scheduling: Add default fair scheduling test

Quoted 7 lines · Marcin Bernatowicz

Verify PF and enabled VFs keep a fair share with the driver-applied default scheduling settings, without overriding scheduling parameters.

Cc Adam Miszczak <[email protected]>
Cc Jakub Kolakowski <[email protected]>
Cc Lukasz Laguna <[email protected]>
Quoted 167 lines
---
  tests/intel/xe_sriov_scheduling.c | 145 ++++++++++++++++++++++++++++++
  1 file changed, 145 insertions(+)
tests/intel/xe_sriov_scheduling.c +145 -0
index 915442380..aa3e5fccc 100644
@@ -1271,6 +1271,112 @@ static void nonpreempt_engine_resets(int pf_fd, int num_vfs,
  	subm_set_fini(set);
  }
 
+static struct job_sched_params
+prepare_default_enabled_job_sched_params(int pf_fd,
+					 const uint8_t *vf_ids,
+					 size_t num_functions,
+					 int job_timeout_ms)
+{
+	struct job_sched_params params = { };
+	uint32_t min_exec_quantum_ms = UINT32_MAX;
+
+	params.sched_params = (struct vf_sched_params) {
+		.exec_quantum_ms = xe_sriov_admin_get_exec_quantum_ms(pf_fd, vf_ids[0]),
+		.preempt_timeout_us = xe_sriov_admin_get_preempt_timeout_us(pf_fd, vf_ids[0]),
+		.priority = xe_sriov_admin_get_sched_priority(pf_fd, vf_ids[0], NULL),
+	};
+
+	for (size_t n = 0; n < num_functions; ++n) {
+		uint32_t exec_quantum_ms =
+			xe_sriov_admin_get_exec_quantum_ms(pf_fd, vf_ids[n]);
+
+		min_exec_quantum_ms = min(min_exec_quantum_ms,
+					  exec_quantum_ms);
+	}
+
+	params.duration_ms = calculate_job_duration_ms(min_exec_quantum_ms);
+	params.num_repeats = adjust_num_repeats(params.duration_ms, num_functions);
+
+	igt_require_f(params.duration_ms +
+		      (num_functions - 1) * params.sched_params.exec_quantum_ms <=
+		      job_timeout_ms,
+		      "Default scheduling eq=%ums across %zu functions exceeds job timeout=%dms\n",
+		      params.sched_params.exec_quantum_ms, num_functions, job_timeout_ms);
+
+	return params;
+}
+
+static void validate_default_enabled_sched_params(int pf_fd,
+						  const uint8_t *vf_ids,
+						  size_t num_functions)
+{
+	for (size_t n = 0; n < num_functions; ++n) {
+		uint32_t exec_quantum_ms =
+			xe_sriov_admin_get_exec_quantum_ms(pf_fd, vf_ids[n]);
+		uint32_t preempt_timeout_us =
+			xe_sriov_admin_get_preempt_timeout_us(pf_fd, vf_ids[n]);
+		enum xe_sriov_sched_priority priority =
+			xe_sriov_admin_get_sched_priority(pf_fd, vf_ids[n], NULL);
+
+		igt_require_f(exec_quantum_ms > 0,
+			      "%s exec_quantum_ms stayed at 0 after enabling VFs\n",
+			      igt_sriov_func_str(vf_ids[n]));
+		igt_require_f(preempt_timeout_us > 0,
+			      "%s preempt_timeout_us stayed at 0 after enabling VFs\n",
+			      igt_sriov_func_str(vf_ids[n]));
+		igt_warn_on_f(priority != XE_SRIOV_SCHED_PRIORITY_LOW,
+			      "%s expected LOW sched_priority after enabling VFs, got %s\n",
+			      igt_sriov_func_str(vf_ids[n]),
+			      xe_sriov_sched_priority_to_string(priority));
+	}
+}
+
+static void ensure_enabled_vfs(int pf_fd, int num_vfs)
+{
+	unsigned int enabled_vfs = igt_sriov_get_enabled_vfs(pf_fd);
+
+	if (enabled_vfs && enabled_vfs != (unsigned int)num_vfs) {
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+		enabled_vfs = 0;
+	}
+
+	if (!enabled_vfs) {
+		xe_sriov_require_default_scheduling_attributes(pf_fd);
+		igt_sriov_enable_driver_autoprobe(pf_fd);
+		igt_sriov_enable_vfs(pf_fd, num_vfs);
+	}
+}
+
+/**
+ * SUBTEST: default-enabled-fair-scheduling
+ * Description:
+ *   Check PF and enabled VFs keep fair scheduling using the driver-applied
+ *   default scheduling settings established when VFs are enabled.
+ */
+static void default_enabled_fair_scheduling(int pf_fd, int num_vfs,
+					    const struct subm_opts *opts,
+					    bool verify_with_perf_counters,
+					    const struct drm_xe_engine_class_instance *eci)
+{
+	uint8_t vf_ids[num_vfs + 1 /*PF*/];
+	uint32_t job_timeout_ms = sysfs_get_job_timeout_ms(pf_fd, eci);
+	struct job_sched_params job_sched_params;
+
+	ensure_enabled_vfs(pf_fd, num_vfs);
+
+	init_vf_ids(vf_ids, ARRAY_SIZE(vf_ids),
+		    &(struct init_vf_ids_opts){ .shuffle = true,
+						.shuffle_pf = true });
+	validate_default_enabled_sched_params(pf_fd, vf_ids, ARRAY_SIZE(vf_ids));
+	job_sched_params = prepare_default_enabled_job_sched_params(pf_fd, vf_ids,
+								    ARRAY_SIZE(vf_ids),
+								    job_timeout_ms);
+
+	verify_applied_scheduling_behavior(pf_fd, vf_ids, ARRAY_SIZE(vf_ids), opts,
+					   verify_with_perf_counters, eci,
+					   &job_sched_params);
+}
+
  static bool skip_visited_gt(bool extended_scope, uint64_t *visited_gts,
  			    unsigned short gt_id)
  {
@@ -1370,6 +1476,45 @@ int igt_main_args("", long_opts, help_str, subm_opts_handler, NULL)
  				  has_perf_event(perf_device, "engine-total-ticks");
  	}
 
+	igt_describe("Check PF and VFs keep fair scheduling using driver defaults applied on VF enable");
+	igt_subtest_with_dynamic("default-enabled-fair-scheduling") {
+		if (extended_scope)
+			for_each_sriov_num_vfs(pf_fd, vf)
+				xe_for_each_engine(pf_fd, eci) {
+					ecls = eci->engine_class;
+					igt_dynamic_f("numvfs-%d-gt%u-%s%u", vf,
+						      eci->gt_id,
+						      xe_engine_class_short_string(ecls),
+						      eci->engine_instance)
+						default_enabled_fair_scheduling(pf_fd, vf,
+										&subm_opts,
+										has_perf_events,
+										eci);
+				}
+
+		for_random_sriov_vf(pf_fd, vf) {
+			uint64_t visited_gts = 0;
+
+			xe_for_each_engine(pf_fd, eci) {
+				if (skip_visited_gt(extended_scope, &visited_gts,
+						    eci->gt_id))
+					continue;
+
+				igt_dynamic_f("numvfs-random-gt%u-%s%u",
+					      eci->gt_id,
+					      xe_engine_class_short_string(eci->engine_class),
+					      eci->engine_instance)
+					default_enabled_fair_scheduling(pf_fd, vf, &subm_opts,
+									has_perf_events,
+									eci);
+			}
+		}
+	}
+
+	igt_fixture() {
+		xe_sriov_disable_vfs_restore_auto_provisioning(pf_fd);
+	}
+
  	for (enum xe_sriov_sched_priority priority = XE_SRIOV_SCHED_PRIORITY_LOW;
  	     priority <= XE_SRIOV_SCHED_PRIORITY_NORMAL;
  	     priority++) {
#18 lore raw

✓ Xe.CI.BAT: success for tests/intel/xe_sriov_scheduling: improve scheduling coverage

In reply to Marcin Bernatowicz
== Series Details ==

== Series Details ==

Series: tests/intel/xe_sriov_scheduling: improve scheduling coverage
URL : https://patchwork.freedesktop.org/series/167417/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_8939_BAT -> XEIGTPW_15265_BAT
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (13 -> 13)
------------------------------

No changes in participating hosts

Changes
-------

No changes found

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

* IGT: IGT_8939 -> IGTPW_15265
* Linux: xe-5138-11a8456527f00d86dc8b23035c324da194fbbadb -> xe-5139-7570b524ddecbe5db4af0c493a047e21bab6b3d6

IGTPW_15265: 2ab4f866e0128d5bfaf9bc599db7d018356caf89 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8939: 8939
xe-5138-11a8456527f00d86dc8b23035c324da194fbbadb: 11a8456527f00d86dc8b23035c324da194fbbadb xe-5139-7570b524ddecbe5db4af0c493a047e21bab6b3d6: 7570b524ddecbe5db4af0c493a047e21bab6b3d6

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/index.html

#19 lore raw

✗ i915.CI.BAT: failure for tests/intel/xe_sriov_scheduling: improve scheduling coverage

In reply to Marcin Bernatowicz
== Series Details ==

== Series Details ==

Series: tests/intel/xe_sriov_scheduling: improve scheduling coverage
URL : https://patchwork.freedesktop.org/series/167417/
State : failure

== Summary ==

CI Bug Log - changes from IGT_8939 -> IGTPW_15265
====================================================

Summary
-------

**FAILURE**

Serious unknown changes coming with IGTPW_15265 absolutely need to be verified manually.

If you think the reported changes have nothing to do with the changes
introduced in IGTPW_15265, please notify your bug team ([email protected]) 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_15265/index.html

Participating hosts (41 -> 40)
------------------------------

Additional (1): bat-adls-6
Missing (2): bat-dg2-13 fi-snb-2520m

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

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

### IGT changes ###

#### Possible regressions ####

* igt@i915_selftest@live@workarounds:
- bat-atsm-1: [PASS][1] -> [ABORT][2] +1 other test abort
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8939/bat-atsm-1/igt@i915_selftest@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-atsm-1/igt@i915_selftest@[email protected]

* igt@kms_flip@basic-flip-vs-wf_vblank:
- fi-bsw-n3050: [PASS][3] -> [DMESG-WARN][4] +7 other tests dmesg-warn
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8939/fi-bsw-n3050/igt@kms_flip@basic-flip-vs-wf_vblank.html
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/fi-bsw-n3050/igt@kms_flip@basic-flip-vs-wf_vblank.html

New tests
---------

New tests have been introduced between IGT_8939 and IGTPW_15265:

### New IGT tests (35) ###

* igt@i915_selftest@allocator-basic-reserve:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@bad-open:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-all:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-api:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-await:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-each:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-fence-flip:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-fence-read:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-gtt:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-read:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-rte:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-subslice-total:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-with_one_bo:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-with_two_bos:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@basic-write:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@create:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@debugfs:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@dmabuf-export:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@dmabuf-fence:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@dmabuf-fence-before:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@dmabuf-mmap:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@error-state-basic:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@flink-lifetime:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@huc-copy:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@hwmon-read:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@load:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@mmap:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@nb-await:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@random-engines:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@reload:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@safe-alignment:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@setversion:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@sysfs:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@unload:
- Statuses :
- Exec time: [None] s

* igt@i915_selftest@wait:
- Statuses :
- Exec time: [None] s

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

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

### IGT changes ###

#### Issues hit ####

* igt@dmabuf@all-tests:
- bat-adls-6: NOTRUN -> [SKIP][5] ([i915#15931])
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@gem_lmem_swapping@parallel-random-engines:
- bat-adls-6: NOTRUN -> [SKIP][6] ([i915#4613]) +3 other tests skip
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@gem_tiled_pread_basic@basic:
- bat-adls-6: NOTRUN -> [SKIP][7] ([i915#15656])
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@intel_hwmon@hwmon-read:
- bat-adls-6: NOTRUN -> [SKIP][8] ([i915#7707]) +1 other test skip
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy:
- bat-adls-6: NOTRUN -> [SKIP][9] ([i915#4103]) +1 other test skip
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@kms_dsc@dsc-basic:
- bat-adls-6: NOTRUN -> [SKIP][10] ([i915#3555] / [i915#3840])
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@kms_force_connector_basic@force-load-detect:
- bat-adls-6: NOTRUN -> [SKIP][11]
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@kms_pm_backlight@basic-brightness:
- bat-adls-6: NOTRUN -> [SKIP][12] ([i915#5354])
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@kms_psr@psr-primary-mmap-gtt:
- bat-adls-6: NOTRUN -> [SKIP][13] ([i915#1072] / [i915#9732]) +3 other tests skip
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@kms_setmode@basic-clone-single-crtc:
- bat-adls-6: NOTRUN -> [SKIP][14] ([i915#3555])
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

* igt@prime_vgem@basic-fence-read:
- bat-adls-6: NOTRUN -> [SKIP][15] ([i915#3291]) +2 other tests skip
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adls-6/igt@[email protected]

#### Possible fixes ####

* igt@i915_pm_rpm@module-reload:
- bat-adlp-6: [DMESG-WARN][16] ([i915#15673]) -> [PASS][17] +78 other tests pass
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8939/bat-adlp-6/igt@[email protected]
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_15265/bat-adlp-6/igt@[email protected]

[i915#1072]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1072
[i915#15656]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15656
[i915#15673]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15673
[i915#15931]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15931
[i915#3291]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3291
[i915#3555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3555
[i915#3840]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3840
[i915#4103]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4103
[i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
[i915#5354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5354
[i915#7707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7707
[i915#9732]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9732

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

* CI: CI-20190529 -> None
* IGT: IGT_8939 -> IGTPW_15265
* Linux: CI_DRM_18562 -> CI_DRM_18563

CI-20190529: 20190529
CI_DRM_18562: 11a8456527f00d86dc8b23035c324da194fbbadb @ git://anongit.freedesktop.org/gfx-ci/linux
CI_DRM_18563: 7570b524ddecbe5db4af0c493a047e21bab6b3d6 @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_15265: 2ab4f866e0128d5bfaf9bc599db7d018356caf89 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8939: 8939

== Logs ==

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

#20 lore raw

✓ Xe.CI.FULL: success for tests/intel/xe_sriov_scheduling: improve scheduling coverage

In reply to Marcin Bernatowicz
== Series Details ==

== Series Details ==

Series: tests/intel/xe_sriov_scheduling: improve scheduling coverage
URL : https://patchwork.freedesktop.org/series/167417/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_8939_FULL -> XEIGTPW_15265_FULL
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (2 -> 2)
------------------------------

No changes in participating hosts

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

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

### IGT changes ###

#### Possible regressions ####

* {igt@xe_sriov_scheduling@equal-throughput-normal-priority} (NEW):
- shard-lnl: NOTRUN -> [SKIP][1] +4 other tests skip
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-5/igt@[email protected]

* {igt@xe_sriov_scheduling@nonpreempt-engine-resets-low-priority} (NEW):
- shard-bmg: NOTRUN -> [SKIP][2]
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@[email protected]

New tests
---------

New tests have been introduced between XEIGT_8939_FULL and XEIGTPW_15265_FULL:

### New IGT tests (13) ###

* igt@xe_sriov_scheduling@default-enabled-fair-scheduling:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 20.94] s

* igt@xe_sriov_scheduling@default-enabled-fair-scheduling@numvfs-random-gt0-rcs0:
- Statuses : 1 pass(s)
- Exec time: [10.80] s

* igt@xe_sriov_scheduling@default-enabled-fair-scheduling@numvfs-random-gt1-vcs0:
- Statuses : 1 pass(s)
- Exec time: [10.13] s

* igt@xe_sriov_scheduling@equal-throughput-low-priority:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 21.99] s

* igt@xe_sriov_scheduling@equal-throughput-low-priority@numvfs-random-gt0-rcs0:
- Statuses : 1 pass(s)
- Exec time: [11.45] s

* igt@xe_sriov_scheduling@equal-throughput-low-priority@numvfs-random-gt1-vcs0:
- Statuses : 1 pass(s)
- Exec time: [10.53] s

* igt@xe_sriov_scheduling@equal-throughput-normal-priority:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 33.78] s

* igt@xe_sriov_scheduling@equal-throughput-normal-priority@numvfs-random-gt0-rcs0:
- Statuses : 1 pass(s)
- Exec time: [22.43] s

* igt@xe_sriov_scheduling@equal-throughput-normal-priority@numvfs-random-gt1-vcs0:
- Statuses : 1 pass(s)
- Exec time: [11.34] s

* igt@xe_sriov_scheduling@nonpreempt-engine-resets-low-priority:
- Statuses : 2 skip(s)
- Exec time: [0.0] s

* igt@xe_sriov_scheduling@nonpreempt-engine-resets-normal-priority:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 78.28] s

* igt@xe_sriov_scheduling@nonpreempt-engine-resets-normal-priority@numvfs-random-gt0-rcs0:
- Statuses : 1 pass(s)
- Exec time: [47.41] s

* igt@xe_sriov_scheduling@nonpreempt-engine-resets-normal-priority@numvfs-random-gt1-vcs0:
- Statuses : 1 pass(s)
- Exec time: [30.87] s

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

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

### IGT changes ###

#### Issues hit ####

* igt@kms_big_fb@4-tiled-32bpp-rotate-270:
- shard-lnl: NOTRUN -> [SKIP][3] ([Intel XE#1407])
[3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-7/igt@[email protected]

* igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip-async-flip:
- shard-lnl: NOTRUN -> [SKIP][4] ([Intel XE#3658] / [Intel XE#7360]) +1 other test skip
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180-hflip-async-flip.html

* igt@kms_big_fb@y-tiled-64bpp-rotate-90:
- shard-bmg: NOTRUN -> [SKIP][5] ([Intel XE#1124]) +2 other tests skip
[5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@kms_big_fb@y-tiled-addfb:
- shard-bmg: NOTRUN -> [SKIP][6] ([Intel XE#2328] / [Intel XE#7367])
[6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][7] ([Intel XE#1467] / [Intel XE#7367])
[7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180:
- shard-lnl: NOTRUN -> [SKIP][8] ([Intel XE#1124]) +4 other tests skip
[8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@kms_bw@connected-linear-tiling-2-displays-target-2160x1440p:
- shard-lnl: NOTRUN -> [SKIP][9] ([Intel XE#7679])
[9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]

* igt@kms_bw@connected-linear-tiling-2-displays-target-3840x2160p:
- shard-bmg: NOTRUN -> [SKIP][10] ([Intel XE#7679]) +1 other test skip
[10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@kms_bw@linear-tiling-3-displays-target-2560x1440p:
- shard-lnl: NOTRUN -> [SKIP][11] ([Intel XE#367])
[11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@kms_ccs@ccs-on-another-bo-4-tiled-mtl-rc-ccs-cc:
- shard-bmg: NOTRUN -> [SKIP][12] ([Intel XE#2887]) +3 other tests skip
[12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-4/igt@[email protected]

* igt@kms_ccs@crc-primary-rotation-180-y-tiled-gen12-rc-ccs:
- shard-lnl: NOTRUN -> [SKIP][13] ([Intel XE#2887]) +6 other tests skip
[13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs@pipe-a-edp-1:
- shard-lnl: NOTRUN -> [SKIP][14] ([Intel XE#2669] / [Intel XE#3433] / [Intel XE#7389]) +3 other tests skip
[14]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@kms_ccs@[email protected]

* igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs@pipe-c-dp-2:
- shard-bmg: NOTRUN -> [INCOMPLETE][15] ([Intel XE#7084] / [Intel XE#8150]) +1 other test incomplete
[15]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-6/igt@kms_ccs@[email protected]

* igt@kms_ccs@crc-primary-suspend-y-tiled-gen12-rc-ccs:
- shard-lnl: NOTRUN -> [SKIP][16] ([Intel XE#3432])
[16]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]
- shard-bmg: NOTRUN -> [SKIP][17] ([Intel XE#3432])
[17]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@kms_chamelium_color@ctm-0-75:
- shard-lnl: NOTRUN -> [SKIP][18] ([Intel XE#306] / [Intel XE#7358])
[18]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]

* igt@kms_chamelium_edid@dp-edid-read:
- shard-bmg: NOTRUN -> [SKIP][19] ([Intel XE#2252]) +2 other tests skip
[19]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@kms_chamelium_frames@dp-crc-fast:
- shard-lnl: NOTRUN -> [SKIP][20] ([Intel XE#373]) +1 other test skip
[20]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

* igt@kms_content_protection@atomic:
- shard-bmg: NOTRUN -> [FAIL][21] ([Intel XE#1178] / [Intel XE#3304] / [Intel XE#7374]) +1 other test fail
[21]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@kms_content_protection@dp-mst-type-0-suspend-resume:
- shard-lnl: NOTRUN -> [SKIP][22] ([Intel XE#6974])
[22]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]

* igt@kms_cursor_crc@cursor-offscreen-32x10:
- shard-bmg: NOTRUN -> [SKIP][23] ([Intel XE#2320]) +1 other test skip
[23]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@kms_cursor_crc@cursor-random-512x512:
- shard-bmg: NOTRUN -> [SKIP][24] ([Intel XE#2321] / [Intel XE#7355])
[24]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-5/igt@[email protected]

* igt@kms_cursor_crc@cursor-rapid-movement-max-size:
- shard-lnl: NOTRUN -> [SKIP][25] ([Intel XE#1424]) +2 other tests skip
[25]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

* igt@kms_cursor_legacy@2x-long-flip-vs-cursor-legacy:
- shard-lnl: NOTRUN -> [SKIP][26] ([Intel XE#309] / [Intel XE#7343])
[26]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-5/igt@[email protected]

* igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size:
- shard-lnl: NOTRUN -> [SKIP][27] ([Intel XE#323] / [Intel XE#6035])
[27]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size.html
- shard-bmg: NOTRUN -> [SKIP][28] ([Intel XE#2286] / [Intel XE#6035])
[28]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-4/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size.html

* igt@kms_dsc@dsc-with-bpc:
- shard-lnl: NOTRUN -> [SKIP][29] ([Intel XE#2244])
[29]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@kms_fbcon_fbt@psr-suspend:
- shard-bmg: NOTRUN -> [SKIP][30] ([Intel XE#6126] / [Intel XE#776])
[30]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-5/igt@[email protected]

* igt@kms_flip@2x-dpms-vs-vblank-race-interruptible:
- shard-lnl: NOTRUN -> [SKIP][31] ([Intel XE#1421]) +1 other test skip
[31]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@[email protected]

* igt@kms_flip@2x-flip-vs-blocking-wf-vblank@ab-dp2-hdmi-a3:
- shard-bmg: [PASS][32] -> [DMESG-FAIL][33] ([Intel XE#5545] / [Intel XE#7774]) +1 other test dmesg-fail
[32]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-4/igt@kms_flip@[email protected]
[33]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@kms_flip@[email protected]

* igt@kms_flip@flip-vs-expired-vblank-interruptible@c-edp1:
- shard-lnl: [PASS][34] -> [FAIL][35] ([Intel XE#301] / [Intel XE#3149])
[34]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-lnl-6/igt@kms_flip@[email protected]
[35]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@kms_flip@[email protected]

* igt@kms_flip_scaled_crc@flip-32bpp-xtile-to-64bpp-xtile-downscaling:
- shard-lnl: NOTRUN -> [SKIP][36] ([Intel XE#1397] / [Intel XE#1745] / [Intel XE#7385])
[36]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@kms_flip_scaled_crc@flip-32bpp-xtile-to-64bpp-xtile-downscaling.html

* igt@kms_flip_scaled_crc@flip-32bpp-xtile-to-64bpp-xtile-downscaling@pipe-a-default-mode:
- shard-lnl: NOTRUN -> [SKIP][37] ([Intel XE#1397] / [Intel XE#7385])
[37]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@kms_flip_scaled_crc@flip-32bpp-xtile-to-64bpp-xtile-downscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling:
- shard-lnl: NOTRUN -> [SKIP][38] ([Intel XE#7178] / [Intel XE#7349])
[38]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling.html

* igt@kms_frontbuffer_tracking@drrs-abgr161616f-draw-render:
- shard-bmg: NOTRUN -> [SKIP][39] ([Intel XE#7061] / [Intel XE#7356])
[39]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@[email protected]

* igt@kms_frontbuffer_tracking@drrshdr-2p-primscrn-pri-indfb-draw-mmap-wc:
- shard-lnl: NOTRUN -> [SKIP][40] ([Intel XE#7905]) +18 other tests skip
[40]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@kms_frontbuffer_tracking@drrshdr-2p-primscrn-pri-indfb-draw-mmap-wc.html

* igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-draw-blt:
- shard-bmg: NOTRUN -> [SKIP][41] ([Intel XE#4141]) +5 other tests skip
[41]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-blt:
- shard-lnl: NOTRUN -> [SKIP][42] ([Intel XE#656] / [Intel XE#7905]) +15 other tests skip
[42]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-7/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-argb161616f-draw-render:
- shard-lnl: NOTRUN -> [SKIP][43] ([Intel XE#7061] / [Intel XE#7356]) +1 other test skip
[43]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcdrrs-modesetfrombusy:
- shard-lnl: NOTRUN -> [SKIP][44] ([Intel XE#6312] / [Intel XE#651]) +3 other tests skip
[44]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-5/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcdrrshdr-1p-primscrn-cur-indfb-draw-render:
- shard-bmg: NOTRUN -> [SKIP][45] ([Intel XE#2311]) +15 other tests skip
[45]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@kms_frontbuffer_tracking@fbcdrrshdr-1p-primscrn-cur-indfb-draw-render.html

* igt@kms_frontbuffer_tracking@fbcdrrshdr-1p-primscrn-indfb-msflip-blt:
- shard-lnl: NOTRUN -> [SKIP][46] ([Intel XE#6312]) +7 other tests skip
[46]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@kms_frontbuffer_tracking@fbcdrrshdr-1p-primscrn-indfb-msflip-blt.html

* igt@kms_frontbuffer_tracking@fbchdr-1p-primscrn-cur-indfb-onoff:
- shard-lnl: NOTRUN -> [SKIP][47] ([Intel XE#7865]) +11 other tests skip
[47]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

* igt@kms_frontbuffer_tracking@hdr-abgr161616f-draw-mmap-wc:
- shard-bmg: NOTRUN -> [SKIP][48] ([Intel XE#7061])
[48]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][49] ([Intel XE#7061]) +1 other test skip
[49]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

* igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt:
- shard-bmg: NOTRUN -> [SKIP][50] ([Intel XE#2313]) +12 other tests skip
[50]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@kms_hdr@static-toggle-suspend@pipe-a-hdmi-a-3-xrgb16161616f:
- shard-bmg: [PASS][51] -> [SKIP][52] ([Intel XE#7915]) +3 other tests skip
[51]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-5/igt@kms_hdr@[email protected]
[52]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-7/igt@kms_hdr@[email protected]

* igt@kms_pipe_stress@stress-xrgb8888-ytiled:
- shard-bmg: NOTRUN -> [SKIP][53] ([Intel XE#4329] / [Intel XE#6912] / [Intel XE#7375])
[53]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-5/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][54] ([Intel XE#4329] / [Intel XE#6912] / [Intel XE#7375])
[54]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

* igt@kms_plane@pixel-format-4-tiled-mtl-rc-ccs-cc-modifier:
- shard-lnl: NOTRUN -> [SKIP][55] ([Intel XE#7283]) +1 other test skip
[55]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@[email protected]

* igt@kms_plane@pixel-format-y-tiled-gen12-rc-ccs-cc-modifier:
- shard-bmg: NOTRUN -> [SKIP][56] ([Intel XE#7283]) +1 other test skip
[56]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@kms_plane_multiple@tiling-y:
- shard-lnl: NOTRUN -> [SKIP][57] ([Intel XE#5020] / [Intel XE#7348])
[57]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-5/igt@[email protected]

* igt@kms_pm_rpm@dpms-lpsp:
- shard-bmg: NOTRUN -> [SKIP][58] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#7383] / [Intel XE#836])
[58]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-6/igt@[email protected]

* igt@kms_psr2_sf@fbc-pr-cursor-plane-move-continuous-exceed-sf:
- shard-lnl: NOTRUN -> [SKIP][59] ([Intel XE#2893] / [Intel XE#7304]) +1 other test skip
[59]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-sf:
- shard-bmg: NOTRUN -> [SKIP][60] ([Intel XE#1489]) +1 other test skip
[60]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-5/igt@[email protected]

* igt@kms_psr2_su@page_flip-p010:
- shard-bmg: NOTRUN -> [SKIP][61] ([Intel XE#2387] / [Intel XE#7429])
[61]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-6/igt@kms_psr2_su@page_flip-p010.html

* igt@kms_psr@fbc-pr-primary-page-flip:
- shard-lnl: NOTRUN -> [SKIP][62] ([Intel XE#1406])
[62]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@kms_psr@psr2-sprite-render:
- shard-bmg: NOTRUN -> [SKIP][63] ([Intel XE#2234] / [Intel XE#2850])
[63]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@kms_rotation_crc@primary-yf-tiled-reflect-x-90:
- shard-bmg: NOTRUN -> [SKIP][64] ([Intel XE#3904] / [Intel XE#7342]) +1 other test skip
[64]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][65] ([Intel XE#3414] / [Intel XE#3904] / [Intel XE#7342])
[65]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]

* igt@kms_scaling_modes@scaling-mode-full-aspect:
- shard-bmg: NOTRUN -> [SKIP][66] ([Intel XE#2413])
[66]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@kms_sharpness_filter@filter-toggle:
- shard-bmg: NOTRUN -> [SKIP][67] ([Intel XE#6503])
[67]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-6/igt@[email protected]

* igt@kms_vrr@max-min@pipe-a-edp-1:
- shard-lnl: [PASS][68] -> [FAIL][69] ([Intel XE#4227]) +1 other test fail
[68]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-lnl-1/igt@kms_vrr@[email protected]
[69]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@kms_vrr@[email protected]

* igt@kms_vrr@negative-basic:
- shard-lnl: NOTRUN -> [SKIP][70] ([Intel XE#1499])
[70]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@xe_ccs@block-copy-uncompressed-inc-dimension:
- shard-bmg: [PASS][71] -> [SKIP][72] ([Intel XE#6703]) +17 other tests skip
[71]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-7/igt@[email protected]
[72]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@xe_create@create-big-vram:
- shard-lnl: NOTRUN -> [SKIP][73] ([Intel XE#1062] / [Intel XE#7318] / [Intel XE#7457])
[73]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@xe_eudebug@discovery-empty:
- shard-bmg: NOTRUN -> [SKIP][74] ([Intel XE#7636]) +2 other tests skip
[74]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-7/igt@[email protected]

* igt@xe_eudebug_online@interrupt-other-debuggable:
- shard-lnl: NOTRUN -> [SKIP][75] ([Intel XE#7636]) +3 other tests skip
[75]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@xe_evict@evict-beng-cm-threads-small:
- shard-lnl: NOTRUN -> [SKIP][76] ([Intel XE#6540] / [Intel XE#688]) +1 other test skip
[76]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]

* igt@xe_exec_balancer@once-virtual-basic:
- shard-lnl: NOTRUN -> [SKIP][77] ([Intel XE#7482]) +8 other tests skip
[77]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

* igt@xe_exec_basic@multigpu-many-execqueues-many-vm-bindexecqueue-userptr-invalidate:
- shard-bmg: NOTRUN -> [SKIP][78] ([Intel XE#2322] / [Intel XE#7372]) +1 other test skip
[78]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-bindexecqueue-userptr-invalidate.html

* igt@xe_exec_basic@multigpu-no-exec-userptr:
- shard-lnl: NOTRUN -> [SKIP][79] ([Intel XE#1392]) +3 other tests skip
[79]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-7/igt@[email protected]

* igt@xe_exec_fault_mode@many-multi-queue-invalid-userptr-fault:
- shard-bmg: NOTRUN -> [SKIP][80] ([Intel XE#7136]) +2 other tests skip
[80]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@[email protected]

* igt@xe_exec_fault_mode@twice-multi-queue-userptr-invalidate-prefetch:
- shard-lnl: NOTRUN -> [SKIP][81] ([Intel XE#7136]) +1 other test skip
[81]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@xe_exec_fault_mode@twice-multi-queue-userptr-invalidate-prefetch.html

* igt@xe_exec_multi_queue@many-queues-basic-smem:
- shard-bmg: NOTRUN -> [SKIP][82] ([Intel XE#6874]) +3 other tests skip
[82]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-6/igt@[email protected]

* igt@xe_exec_multi_queue@many-queues-preempt-mode-fault-close-fd:
- shard-lnl: NOTRUN -> [SKIP][83] ([Intel XE#6874]) +11 other tests skip
[83]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@[email protected]

* igt@xe_exec_reset@multi-queue-cancel-on-secondary:
- shard-bmg: NOTRUN -> [SKIP][84] ([Intel XE#7866])
[84]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@xe_exec_system_allocator@many-large-execqueues-malloc-mlock-nomemset:
- shard-bmg: [PASS][85] -> [INCOMPLETE][86] ([Intel XE#8159])
[85]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-3/igt@xe_exec_system_allocator@many-large-execqueues-malloc-mlock-nomemset.html
[86]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-8/igt@xe_exec_system_allocator@many-large-execqueues-malloc-mlock-nomemset.html

* igt@xe_exec_system_allocator@twice-malloc-multi-fault:
- shard-lnl: [PASS][87] -> [ABORT][88] ([Intel XE#8007])
[87]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-lnl-1/igt@[email protected]
[88]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-2/igt@[email protected]

* igt@xe_exec_threads@threads-multi-queue-cm-rebind:
- shard-lnl: NOTRUN -> [SKIP][89] ([Intel XE#7138]) +4 other tests skip
[89]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@xe_exec_threads@threads-multi-queue-mixed-fd-userptr:
- shard-bmg: NOTRUN -> [SKIP][90] ([Intel XE#7138]) +2 other tests skip
[90]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@[email protected]

* igt@xe_mmap@pci-membarrier-bad-pagesize:
- shard-lnl: NOTRUN -> [SKIP][91] ([Intel XE#5100] / [Intel XE#7322] / [Intel XE#7408])
[91]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-5/igt@[email protected]

* igt@xe_multigpu_svm@mgpu-coherency-conflict:
- shard-lnl: NOTRUN -> [SKIP][92] ([Intel XE#6964])
[92]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-7/igt@[email protected]
- shard-bmg: NOTRUN -> [SKIP][93] ([Intel XE#6964]) +1 other test skip
[93]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@xe_noexec_ping_pong@basic:
- shard-lnl: NOTRUN -> [SKIP][94] ([Intel XE#6259] / [Intel XE#7324] / [Intel XE#7406])
[94]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-7/igt@[email protected]

* igt@xe_page_reclaim@invalid-1g:
- shard-lnl: NOTRUN -> [SKIP][95] ([Intel XE#7793])
[95]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-5/igt@[email protected]

* igt@xe_pat@xa-app-transient-media-on:
- shard-bmg: NOTRUN -> [SKIP][96] ([Intel XE#7590])
[96]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-4/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][97] ([Intel XE#7590] / [Intel XE#7772])
[97]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-7/igt@[email protected]

* igt@xe_pm@d3cold-i2c:
- shard-bmg: NOTRUN -> [SKIP][98] ([Intel XE#5694] / [Intel XE#7370])
[98]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-1/igt@[email protected]

* igt@xe_pmu@all-fn-engine-activity-load:
- shard-lnl: NOTRUN -> [SKIP][99] ([Intel XE#4650] / [Intel XE#7347])
[99]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-8/igt@[email protected]

* igt@xe_pxp@pxp-stale-bo-exec-post-termination-irq:
- shard-bmg: NOTRUN -> [SKIP][100] ([Intel XE#4733] / [Intel XE#7417])
[100]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-9/igt@[email protected]

* igt@xe_query@multigpu-query-gt-list:
- shard-lnl: NOTRUN -> [SKIP][101] ([Intel XE#944]) +1 other test skip
[101]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@xe_query@multigpu-query-hwconfig:
- shard-bmg: NOTRUN -> [SKIP][102] ([Intel XE#944]) +2 other tests skip
[102]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-4/igt@[email protected]

* igt@xe_sriov_admin@bulk-sched-priority-vfs-disabled:
- shard-lnl: NOTRUN -> [SKIP][103] ([Intel XE#7174])
[103]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-4/igt@[email protected]

* igt@xe_vm@large-split-binds-134217728:
- shard-bmg: NOTRUN -> [SKIP][104] ([Intel XE#6703]) +2 other tests skip
[104]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

#### Possible fixes ####

* igt@kms_cursor_legacy@flip-vs-cursor-atomic:
- shard-bmg: [FAIL][105] ([Intel XE#7571]) -> [PASS][106]
[105]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-4/igt@[email protected]
[106]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-8/igt@[email protected]

* igt@kms_cursor_legacy@flip-vs-cursor-legacy:
- shard-bmg: [FAIL][107] ([Intel XE#7809]) -> [PASS][108]
[107]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-6/igt@[email protected]
[108]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-10/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1:
- shard-lnl: [FAIL][109] ([Intel XE#301]) -> [PASS][110] +1 other test pass
[109]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-lnl-6/igt@kms_flip@[email protected]
[110]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@kms_flip@[email protected]

* igt@kms_hdr@static-toggle-dpms@pipe-a-hdmi-a-3-xrgb2101010:
- shard-bmg: [SKIP][111] ([Intel XE#7915]) -> [PASS][112] +3 other tests pass
[111]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-8/igt@kms_hdr@[email protected]
[112]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-5/igt@kms_hdr@[email protected]

* igt@xe_copy_basic@mem-page-copy-17:
- shard-lnl: [ABORT][113] ([Intel XE#8007]) -> [PASS][114]
[113]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-lnl-3/igt@[email protected]
[114]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-1/igt@[email protected]

#### Warnings ####

* igt@kms_bw@connected-linear-tiling-3-displays-target-2160x1440p:
- shard-bmg: [SKIP][115] ([Intel XE#7679]) -> [SKIP][116] ([Intel XE#6703])
[115]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-6/igt@[email protected]
[116]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_ccs@random-ccs-data-y-tiled-gen12-rc-ccs:
- shard-bmg: [SKIP][117] ([Intel XE#2887]) -> [SKIP][118] ([Intel XE#6703])
[117]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-4/igt@[email protected]
[118]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle:
- shard-bmg: [SKIP][119] ([Intel XE#2286] / [Intel XE#6035]) -> [SKIP][120] ([Intel XE#6703])
[119]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-10/igt@[email protected]
[120]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_fbc_dirty_rect@fbc-dirty-rectangle-dirtyfb-tests:
- shard-bmg: [SKIP][121] ([Intel XE#4422] / [Intel XE#7442]) -> [SKIP][122] ([Intel XE#6703])
[121]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-3/igt@[email protected]
[122]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank-interruptible:
- shard-lnl: [FAIL][123] ([Intel XE#301]) -> [FAIL][124] ([Intel XE#301] / [Intel XE#3149])
[123]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-lnl-6/igt@[email protected]
[124]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-lnl-3/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-1p-primscrn-shrfb-plflip-blt:
- shard-bmg: [SKIP][125] ([Intel XE#4141]) -> [SKIP][126] ([Intel XE#6703]) +1 other test skip
[125]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-2/igt@[email protected]
[126]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcdrrshdr-2p-scndscrn-spr-indfb-fullscreen:
- shard-bmg: [SKIP][127] ([Intel XE#2311]) -> [SKIP][128] ([Intel XE#6703])
[127]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-1/igt@kms_frontbuffer_tracking@fbcdrrshdr-2p-scndscrn-spr-indfb-fullscreen.html
[128]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcdrrshdr-2p-scndscrn-spr-indfb-fullscreen.html

* igt@kms_frontbuffer_tracking@fbchdr-abgr161616f-draw-blt:
- shard-bmg: [SKIP][129] ([Intel XE#7061]) -> [SKIP][130] ([Intel XE#6703])
[129]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-2/igt@[email protected]
[130]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcpsrhdr-1p-primscrn-shrfb-plflip-blt:
- shard-bmg: [SKIP][131] ([Intel XE#2313]) -> [SKIP][132] ([Intel XE#6703]) +1 other test skip
[131]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcpsrhdr-1p-primscrn-shrfb-plflip-blt.html
[132]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@kms_frontbuffer_tracking@fbcpsrhdr-1p-primscrn-shrfb-plflip-blt.html

* igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75:
- shard-bmg: [SKIP][133] ([Intel XE#2763] / [Intel XE#6886]) -> [SKIP][134] ([Intel XE#6703])
[133]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-6/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75.html
[134]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-75.html

* igt@kms_tiled_display@basic-test-pattern:
- shard-bmg: [SKIP][135] ([Intel XE#2426] / [Intel XE#5848]) -> [FAIL][136] ([Intel XE#1729] / [Intel XE#7424])
[135]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-7/igt@[email protected]
[136]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-5/igt@[email protected]

* igt@kms_tiled_display@basic-test-pattern-with-chamelium:
- shard-bmg: [SKIP][137] ([Intel XE#2426] / [Intel XE#5848]) -> [SKIP][138] ([Intel XE#2509] / [Intel XE#7437])
[137]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-8/igt@[email protected]
[138]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-4/igt@[email protected]

* igt@xe_exec_threads@threads-multi-queue-mixed-fd-userptr-rebind:
- shard-bmg: [SKIP][139] ([Intel XE#7138]) -> [SKIP][140] ([Intel XE#6703])
[139]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8939/shard-bmg-7/igt@[email protected]
[140]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/shard-bmg-2/igt@[email protected]

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

[Intel XE#1062]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1062
[Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
[Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
[Intel XE#1392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1392
[Intel XE#1397]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1397
[Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406
[Intel XE#1407]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1407
[Intel XE#1421]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1421
[Intel XE#1424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1424
[Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439
[Intel XE#1467]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1467
[Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
[Intel XE#1499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1499
[Intel XE#1729]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1729
[Intel XE#1745]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1745
[Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
[Intel XE#2244]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2244
[Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
[Intel XE#2286]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2286
[Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
[Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
[Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
[Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321
[Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
[Intel XE#2328]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2328
[Intel XE#2387]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2387
[Intel XE#2413]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2413
[Intel XE#2426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2426
[Intel XE#2509]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2509
[Intel XE#2669]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2669
[Intel XE#2763]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2763
[Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
[Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
[Intel XE#2893]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2893
[Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
[Intel XE#306]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/306
[Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
[Intel XE#3141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3141
[Intel XE#3149]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3149
[Intel XE#323]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/323
[Intel XE#3304]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3304
[Intel XE#3414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3414
[Intel XE#3432]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3432
[Intel XE#3433]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3433
[Intel XE#3658]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3658
[Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
[Intel XE#373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/373
[Intel XE#3904]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3904
[Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
[Intel XE#4227]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4227
[Intel XE#4329]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4329
[Intel XE#4422]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4422
[Intel XE#4650]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4650
[Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733
[Intel XE#5020]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5020
[Intel XE#5100]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5100
[Intel XE#5545]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5545
[Intel XE#5694]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5694
[Intel XE#5848]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5848
[Intel XE#6035]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6035
[Intel XE#6126]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6126
[Intel XE#6259]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6259
[Intel XE#6312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6312
[Intel XE#6503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6503
[Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
[Intel XE#6540]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6540
[Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
[Intel XE#6703]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6703
[Intel XE#6874]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6874
[Intel XE#688]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/688
[Intel XE#6886]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6886
[Intel XE#6912]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6912
[Intel XE#6964]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6964
[Intel XE#6974]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6974
[Intel XE#7061]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7061
[Intel XE#7084]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7084
[Intel XE#7136]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7136
[Intel XE#7138]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7138
[Intel XE#7174]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7174
[Intel XE#7178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7178
[Intel XE#7283]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7283
[Intel XE#7304]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7304
[Intel XE#7318]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7318
[Intel XE#7322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7322
[Intel XE#7324]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7324
[Intel XE#7342]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7342
[Intel XE#7343]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7343
[Intel XE#7347]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7347
[Intel XE#7348]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7348
[Intel XE#7349]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7349
[Intel XE#7355]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7355
[Intel XE#7356]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7356
[Intel XE#7358]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7358
[Intel XE#7360]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7360
[Intel XE#7367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7367
[Intel XE#7370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7370
[Intel XE#7372]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7372
[Intel XE#7374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7374
[Intel XE#7375]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7375
[Intel XE#7383]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7383
[Intel XE#7385]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7385
[Intel XE#7389]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7389
[Intel XE#7406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7406
[Intel XE#7408]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7408
[Intel XE#7417]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7417
[Intel XE#7424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7424
[Intel XE#7429]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7429
[Intel XE#7437]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7437
[Intel XE#7442]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7442
[Intel XE#7457]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7457
[Intel XE#7482]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7482
[Intel XE#7571]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7571
[Intel XE#7590]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7590
[Intel XE#7636]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7636
[Intel XE#7679]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7679
[Intel XE#776]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/776
[Intel XE#7772]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7772
[Intel XE#7774]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7774
[Intel XE#7793]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7793
[Intel XE#7809]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7809
[Intel XE#7865]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7865
[Intel XE#7866]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7866
[Intel XE#7905]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7905
[Intel XE#7915]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7915
[Intel XE#8007]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8007
[Intel XE#8150]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8150
[Intel XE#8159]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8159
[Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836
[Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944

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

* IGT: IGT_8939 -> IGTPW_15265
* Linux: xe-5138-11a8456527f00d86dc8b23035c324da194fbbadb -> xe-5139-7570b524ddecbe5db4af0c493a047e21bab6b3d6

IGTPW_15265: 2ab4f866e0128d5bfaf9bc599db7d018356caf89 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8939: 8939
xe-5138-11a8456527f00d86dc8b23035c324da194fbbadb: 11a8456527f00d86dc8b23035c324da194fbbadb xe-5139-7570b524ddecbe5db4af0c493a047e21bab6b3d6: 7570b524ddecbe5db4af0c493a047e21bab6b3d6

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_15265/index.html