Skip to contentSkip to conversation

Improve anti-pre-emption w/a for compute workloads

PATCH Superseded [email protected] 3 participants 19 messages Sep 29, 2022 – Oct 6, 2022

Subsystems (2)

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v4 cover Improve anti-pre-emption w/a for compute workloads

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible on current hardware. Thus the pre-emption timeout was disabled as a workaround to prevent unwanted resets. Instead, the hang detection was left to the heartbeat and its (longer) timeout. This is undesirable with GuC submission as the heartbeat is a full GT reset rather than a per engine reset and so is much more destructive. Instead, just bump the pre-emption timeout to a big value. Also, update the heartbeat to allow such a long pre-emption delay in the final heartbeat period.

v2: Add clamping helpers.
v3: Remove long timeout algorithm and replace with hard coded value (review feedback from Tvrtko). Also, fix execlist selftest failure and fix bug in compute enabling patch related to pre-emption timeouts.
v4: Add multiple BUG_ONs to re-check already range checked values (Tvrtko)

John Harrison (4):
drm/i915/guc: Limit scheduling properties to avoid overflow drm/i915: Fix compute pre-emption w/a to apply to compute engines drm/i915: Make the heartbeat play nice with long pre-emption timeouts drm/i915: Improve long running compute w/a for GuC submission

 drivers/gpu/drm/i915/Kconfig.profile          |  26 ++++-
 drivers/gpu/drm/i915/gt/intel_engine.h        |   6 ++
 drivers/gpu/drm/i915/gt/intel_engine_cs.c     | 102 +++++++++++++++---
 .../gpu/drm/i915/gt/intel_engine_heartbeat.c  |  19 ++++
 drivers/gpu/drm/i915/gt/sysfs_engines.c       |  25 +++--
 drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h   |  21 ++++
 .../gpu/drm/i915/gt/uc/intel_guc_submission.c |   8 ++
 7 files changed, 179 insertions(+), 28 deletions(-)
Signature · 1 line
2.37.3
#1 lore raw

PATCH v4 1/4 drm/i915/guc: Limit scheduling properties to avoid overflow

From: John Harrison <[email protected]>

GuC converts the pre-emption timeout and timeslice quantum values into clock ticks internally. That significantly reduces the point of 32bit overflow. On current platforms, worst case scenario is approximately 110 seconds. Rather than allowing the user to set higher values and then get confused by early timeouts, add limits when setting these values.

v2: Add helper functions for clamping (review feedback from Tvrtko).
v3: Add a bunch of BUG_ON range checks in addition to the checks already in the clamping functions (Tvrtko)

---
 drivers/gpu/drm/i915/gt/intel_engine.h        |  6 ++
 drivers/gpu/drm/i915/gt/intel_engine_cs.c     | 69 +++++++++++++++++++
 drivers/gpu/drm/i915/gt/sysfs_engines.c       | 25 ++++---
 drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h   | 21 ++++++
 .../gpu/drm/i915/gt/uc/intel_guc_submission.c |  8 +++
 5 files changed, 119 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/gt/intel_engine.h +6 -0
index 04e435bce79bd..cbc8b857d5f7a 100644
@@ -348,4 +348,10 @@ intel_engine_get_hung_context(struct intel_engine_cs *engine)
 	return engine->hung_ce;
 }
 
+u64 intel_clamp_heartbeat_interval_ms(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_max_busywait_duration_ns(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_preempt_timeout_ms(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_stop_timeout_ms(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_timeslice_duration_ms(struct intel_engine_cs *engine, u64 value);
+
 #endif /* _INTEL_RINGBUFFER_H_ */
drivers/gpu/drm/i915/gt/intel_engine_cs.c +69 -0

81 lines not on this page · raw message

drivers/gpu/drm/i915/gt/sysfs_engines.c +15 -10
index 9670310562029..f2d9858d827c2 100644
@@ -144,7 +144,7 @@ max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
 	       const char *buf, size_t count)
 {
 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long duration;
+	unsigned long long duration, clamped;
 	int err;
 
 	/*
@@ -168,7 +168,8 @@ max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
 	if (err)
 		return err;
 
-	if (duration > jiffies_to_nsecs(2))
+	clamped = intel_clamp_max_busywait_duration_ns(engine, duration);
+	if (duration != clamped)
 		return -EINVAL;
 
 	WRITE_ONCE(engine->props.max_busywait_duration_ns, duration);
@@ -203,7 +204,7 @@ timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long duration;
+	unsigned long long duration, clamped;
 	int err;
 
 	/*
@@ -218,7 +219,8 @@ timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
 	if (err)
 		return err;
 
-	if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_timeslice_duration_ms(engine, duration);
+	if (duration != clamped)
 		return -EINVAL;
 
 	WRITE_ONCE(engine->props.timeslice_duration_ms, duration);
@@ -256,7 +258,7 @@ stop_store(struct kobject *kobj, struct kobj_attribute *attr,
 	   const char *buf, size_t count)
 {
 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long duration;
+	unsigned long long duration, clamped;
 	int err;
 
 	/*
@@ -272,7 +274,8 @@ stop_store(struct kobject *kobj, struct kobj_attribute *attr,
 	if (err)
 		return err;
 
-	if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_stop_timeout_ms(engine, duration);
+	if (duration != clamped)
 		return -EINVAL;
 
 	WRITE_ONCE(engine->props.stop_timeout_ms, duration);
@@ -306,7 +309,7 @@ preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
 		      const char *buf, size_t count)
 {
 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long timeout;
+	unsigned long long timeout, clamped;
 	int err;
 
 	/*
@@ -322,7 +325,8 @@ preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
 	if (err)
 		return err;
 
-	if (timeout > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_preempt_timeout_ms(engine, timeout);
+	if (timeout != clamped)
 		return -EINVAL;
 
 	WRITE_ONCE(engine->props.preempt_timeout_ms, timeout);
@@ -362,7 +366,7 @@ heartbeat_store(struct kobject *kobj, struct kobj_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long delay;
+	unsigned long long delay, clamped;
 	int err;
 
 	/*
@@ -379,7 +383,8 @@ heartbeat_store(struct kobject *kobj, struct kobj_attribute *attr,
 	if (err)
 		return err;
 
-	if (delay >= jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_heartbeat_interval_ms(engine, delay);
+	if (delay != clamped)
 		return -EINVAL;
 
 	err = intel_engine_set_heartbeat(engine, delay);
drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h +21 -0
index e7a7fb450f442..968ebd79dce70 100644
@@ -327,6 +327,27 @@ struct guc_update_scheduling_policy {
 
 #define GLOBAL_POLICY_DEFAULT_DPC_PROMOTE_TIME_US 500000
 
+/*
+ * GuC converts the timeout to clock ticks internally. Different platforms have
+ * different GuC clocks. Thus, the maximum value before overflow is platform
+ * dependent. Current worst case scenario is about 110s. So, the spec says to
+ * limit to 100s to be safe.
+ */
+#define GUC_POLICY_MAX_EXEC_QUANTUM_US		(100 * 1000 * 1000UL)
+#define GUC_POLICY_MAX_PREEMPT_TIMEOUT_US	(100 * 1000 * 1000UL)
+
+static inline u32 guc_policy_max_exec_quantum_ms(void)
+{
+	BUILD_BUG_ON(GUC_POLICY_MAX_EXEC_QUANTUM_US >= UINT_MAX);
+	return GUC_POLICY_MAX_EXEC_QUANTUM_US / 1000;
+}
+
+static inline u32 guc_policy_max_preempt_timeout_ms(void)
+{
+	BUILD_BUG_ON(GUC_POLICY_MAX_PREEMPT_TIMEOUT_US >= UINT_MAX);
+	return GUC_POLICY_MAX_PREEMPT_TIMEOUT_US / 1000;
+}
+
 struct guc_policies {
 	u32 submission_queue_depth[GUC_MAX_ENGINE_CLASSES];
 	/* In micro seconds. How much time to allow before DPC processing is
drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c +8 -0
index 0ef295a94060c..039c187ce570d 100644
@@ -2430,6 +2430,10 @@ static int guc_context_policy_init_v70(struct intel_context *ce, bool loop)
 	int ret;
 
 	/* NB: For both of these, zero means disabled. */
+	GEM_BUG_ON(overflows_type(engine->props.timeslice_duration_ms * 1000,
+				  execution_quantum));
+	GEM_BUG_ON(overflows_type(engine->props.preempt_timeout_ms * 1000,
+				  preemption_timeout));
 	execution_quantum = engine->props.timeslice_duration_ms * 1000;
 	preemption_timeout = engine->props.preempt_timeout_ms * 1000;
 
@@ -2463,6 +2467,10 @@ static void guc_context_policy_init_v69(struct intel_engine_cs *engine,
 		desc->policy_flags |= CONTEXT_POLICY_FLAG_PREEMPT_TO_IDLE_V69;
 
 	/* NB: For both of these, zero means disabled. */
+	GEM_BUG_ON(overflows_type(engine->props.timeslice_duration_ms * 1000,
+				  desc->execution_quantum));
+	GEM_BUG_ON(overflows_type(engine->props.preempt_timeout_ms * 1000,
+				  desc->preemption_timeout));
 	desc->execution_quantum = engine->props.timeslice_duration_ms * 1000;
 	desc->preemption_timeout = engine->props.preempt_timeout_ms * 1000;
 }
Signature · 1 line
2.37.3
Acked-by on v4 1/4
#2 lore raw

Re: [Intel-gfx] [PATCH v4 1/4] drm/i915/guc: Limit scheduling properties to avoid overflow

Quoted 9 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

GuC converts the pre-emption timeout and timeslice quantum values into clock ticks internally. That significantly reduces the point of 32bit overflow. On current platforms, worst case scenario is approximately 110 seconds. Rather than allowing the user to set higher values and then get confused by early timeouts, add limits when setting these values.

Quoted 6 lines

v2: Add helper functions for clamping (review feedback from Tvrtko).
v3: Add a bunch of BUG_ON range checks in addition to the checks already in the clamping functions (Tvrtko)

Regards,

Tvrtko

Quoted 267 lines
---
  drivers/gpu/drm/i915/gt/intel_engine.h        |  6 ++
  drivers/gpu/drm/i915/gt/intel_engine_cs.c     | 69 +++++++++++++++++++
  drivers/gpu/drm/i915/gt/sysfs_engines.c       | 25 ++++---
  drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h   | 21 ++++++
  .../gpu/drm/i915/gt/uc/intel_guc_submission.c |  8 +++
  5 files changed, 119 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/gt/intel_engine.h +6 -0
index 04e435bce79bd..cbc8b857d5f7a 100644
@@ -348,4 +348,10 @@ intel_engine_get_hung_context(struct intel_engine_cs *engine)
  	return engine->hung_ce;
  }
 
+u64 intel_clamp_heartbeat_interval_ms(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_max_busywait_duration_ns(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_preempt_timeout_ms(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_stop_timeout_ms(struct intel_engine_cs *engine, u64 value);
+u64 intel_clamp_timeslice_duration_ms(struct intel_engine_cs *engine, u64 value);
+
  #endif /* _INTEL_RINGBUFFER_H_ */
drivers/gpu/drm/i915/gt/intel_engine_cs.c +69 -0
index 2ddcad497fa30..8f16955f0821e 100644
@@ -512,6 +512,26 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id,
  		engine->flags |= I915_ENGINE_HAS_EU_PRIORITY;
  	}
 
+	/* Cap properties according to any system limits */
+#define CLAMP_PROP(field) \
+	do { \
+		u64 clamp = intel_clamp_##field(engine, engine->props.field); \
+		if (clamp != engine->props.field) { \
+			drm_notice(&engine->i915->drm, \
+				   "Warning, clamping %s to %lld to prevent overflow\n", \
+				   #field, clamp); \
+			engine->props.field = clamp; \
+		} \
+	} while (0)
+
+	CLAMP_PROP(heartbeat_interval_ms);
+	CLAMP_PROP(max_busywait_duration_ns);
+	CLAMP_PROP(preempt_timeout_ms);
+	CLAMP_PROP(stop_timeout_ms);
+	CLAMP_PROP(timeslice_duration_ms);
+
+#undef CLAMP_PROP
+
  	engine->defaults = engine->props; /* never to change again */
 
  	engine->context_size = intel_engine_context_size(gt, engine->class);
@@ -534,6 +554,55 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id,
  	return 0;
  }
 
+u64 intel_clamp_heartbeat_interval_ms(struct intel_engine_cs *engine, u64 value)
+{
+	value = min_t(u64, value, jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT));
+
+	return value;
+}
+
+u64 intel_clamp_max_busywait_duration_ns(struct intel_engine_cs *engine, u64 value)
+{
+	value = min(value, jiffies_to_nsecs(2));
+
+	return value;
+}
+
+u64 intel_clamp_preempt_timeout_ms(struct intel_engine_cs *engine, u64 value)
+{
+	/*
+	 * NB: The GuC API only supports 32bit values. However, the limit is further
+	 * reduced due to internal calculations which would otherwise overflow.
+	 */
+	if (intel_guc_submission_is_wanted(&engine->gt->uc.guc))
+		value = min_t(u64, value, guc_policy_max_preempt_timeout_ms());
+
+	value = min_t(u64, value, jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT));
+
+	return value;
+}
+
+u64 intel_clamp_stop_timeout_ms(struct intel_engine_cs *engine, u64 value)
+{
+	value = min_t(u64, value, jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT));
+
+	return value;
+}
+
+u64 intel_clamp_timeslice_duration_ms(struct intel_engine_cs *engine, u64 value)
+{
+	/*
+	 * NB: The GuC API only supports 32bit values. However, the limit is further
+	 * reduced due to internal calculations which would otherwise overflow.
+	 */
+	if (intel_guc_submission_is_wanted(&engine->gt->uc.guc))
+		value = min_t(u64, value, guc_policy_max_exec_quantum_ms());
+
+	value = min_t(u64, value, jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT));
+
+	return value;
+}
+
  static void __setup_engine_capabilities(struct intel_engine_cs *engine)
  {
  	struct drm_i915_private *i915 = engine->i915;
drivers/gpu/drm/i915/gt/sysfs_engines.c +15 -10
index 9670310562029..f2d9858d827c2 100644
@@ -144,7 +144,7 @@ max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
  	       const char *buf, size_t count)
  {
  	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long duration;
+	unsigned long long duration, clamped;
  	int err;
 
  	/*
@@ -168,7 +168,8 @@ max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
  	if (err)
  		return err;
 
-	if (duration > jiffies_to_nsecs(2))
+	clamped = intel_clamp_max_busywait_duration_ns(engine, duration);
+	if (duration != clamped)
  		return -EINVAL;
 
  	WRITE_ONCE(engine->props.max_busywait_duration_ns, duration);
@@ -203,7 +204,7 @@ timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
  		const char *buf, size_t count)
  {
  	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long duration;
+	unsigned long long duration, clamped;
  	int err;
 
  	/*
@@ -218,7 +219,8 @@ timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
  	if (err)
  		return err;
 
-	if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_timeslice_duration_ms(engine, duration);
+	if (duration != clamped)
  		return -EINVAL;
 
  	WRITE_ONCE(engine->props.timeslice_duration_ms, duration);
@@ -256,7 +258,7 @@ stop_store(struct kobject *kobj, struct kobj_attribute *attr,
  	   const char *buf, size_t count)
  {
  	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long duration;
+	unsigned long long duration, clamped;
  	int err;
 
  	/*
@@ -272,7 +274,8 @@ stop_store(struct kobject *kobj, struct kobj_attribute *attr,
  	if (err)
  		return err;
 
-	if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_stop_timeout_ms(engine, duration);
+	if (duration != clamped)
  		return -EINVAL;
 
  	WRITE_ONCE(engine->props.stop_timeout_ms, duration);
@@ -306,7 +309,7 @@ preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
  		      const char *buf, size_t count)
  {
  	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long timeout;
+	unsigned long long timeout, clamped;
  	int err;
 
  	/*
@@ -322,7 +325,8 @@ preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
  	if (err)
  		return err;
 
-	if (timeout > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_preempt_timeout_ms(engine, timeout);
+	if (timeout != clamped)
  		return -EINVAL;
 
  	WRITE_ONCE(engine->props.preempt_timeout_ms, timeout);
@@ -362,7 +366,7 @@ heartbeat_store(struct kobject *kobj, struct kobj_attribute *attr,
  		const char *buf, size_t count)
  {
  	struct intel_engine_cs *engine = kobj_to_engine(kobj);
-	unsigned long long delay;
+	unsigned long long delay, clamped;
  	int err;
 
  	/*
@@ -379,7 +383,8 @@ heartbeat_store(struct kobject *kobj, struct kobj_attribute *attr,
  	if (err)
  		return err;
 
-	if (delay >= jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
+	clamped = intel_clamp_heartbeat_interval_ms(engine, delay);
+	if (delay != clamped)
  		return -EINVAL;
 
  	err = intel_engine_set_heartbeat(engine, delay);
drivers/gpu/drm/i915/gt/uc/intel_guc_fwif.h +21 -0
index e7a7fb450f442..968ebd79dce70 100644
@@ -327,6 +327,27 @@ struct guc_update_scheduling_policy {
 
  #define GLOBAL_POLICY_DEFAULT_DPC_PROMOTE_TIME_US 500000
 
+/*
+ * GuC converts the timeout to clock ticks internally. Different platforms have
+ * different GuC clocks. Thus, the maximum value before overflow is platform
+ * dependent. Current worst case scenario is about 110s. So, the spec says to
+ * limit to 100s to be safe.
+ */
+#define GUC_POLICY_MAX_EXEC_QUANTUM_US		(100 * 1000 * 1000UL)
+#define GUC_POLICY_MAX_PREEMPT_TIMEOUT_US	(100 * 1000 * 1000UL)
+
+static inline u32 guc_policy_max_exec_quantum_ms(void)
+{
+	BUILD_BUG_ON(GUC_POLICY_MAX_EXEC_QUANTUM_US >= UINT_MAX);
+	return GUC_POLICY_MAX_EXEC_QUANTUM_US / 1000;
+}
+
+static inline u32 guc_policy_max_preempt_timeout_ms(void)
+{
+	BUILD_BUG_ON(GUC_POLICY_MAX_PREEMPT_TIMEOUT_US >= UINT_MAX);
+	return GUC_POLICY_MAX_PREEMPT_TIMEOUT_US / 1000;
+}
+
  struct guc_policies {
  	u32 submission_queue_depth[GUC_MAX_ENGINE_CLASSES];
  	/* In micro seconds. How much time to allow before DPC processing is
drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c +8 -0
index 0ef295a94060c..039c187ce570d 100644
@@ -2430,6 +2430,10 @@ static int guc_context_policy_init_v70(struct intel_context *ce, bool loop)
  	int ret;
 
  	/* NB: For both of these, zero means disabled. */
+	GEM_BUG_ON(overflows_type(engine->props.timeslice_duration_ms * 1000,
+				  execution_quantum));
+	GEM_BUG_ON(overflows_type(engine->props.preempt_timeout_ms * 1000,
+				  preemption_timeout));
  	execution_quantum = engine->props.timeslice_duration_ms * 1000;
  	preemption_timeout = engine->props.preempt_timeout_ms * 1000;
 
@@ -2463,6 +2467,10 @@ static void guc_context_policy_init_v69(struct intel_engine_cs *engine,
  		desc->policy_flags |= CONTEXT_POLICY_FLAG_PREEMPT_TO_IDLE_V69;
 
  	/* NB: For both of these, zero means disabled. */
+	GEM_BUG_ON(overflows_type(engine->props.timeslice_duration_ms * 1000,
+				  desc->execution_quantum));
+	GEM_BUG_ON(overflows_type(engine->props.preempt_timeout_ms * 1000,
+				  desc->preemption_timeout));
  	desc->execution_quantum = engine->props.timeslice_duration_ms * 1000;
  	desc->preemption_timeout = engine->props.preempt_timeout_ms * 1000;
  }
#3 lore raw

PATCH v4 2/4 drm/i915: Fix compute pre-emption w/a to apply to compute engines

In reply to [email protected]

From: John Harrison <[email protected]>

An earlier patch added support for compute engines. However, it missed enabling the anti-pre-emption w/a for the new engine class. So move the 'compute capable' flag earlier and use it for the pre-emption w/a test.

Fixes c674c5b9342e ("drm/i915/xehp: CCS should use RCS setup functions")
Cc Tvrtko Ursulin <[email protected]>
Cc Daniele Ceraolo Spurio <[email protected]>
Cc Aravind Iddamsetty <[email protected]>
Cc Matt Roper <[email protected]>
Cc Tvrtko Ursulin <[email protected]>
Cc Daniel Vetter <[email protected]>
Cc Maarten Lankhorst <[email protected]>
Cc Lucas De Marchi <[email protected]>
Cc John Harrison <[email protected]>
Cc Jason Ekstrand <[email protected]>
Cc "Michał Winiarski" <[email protected]>
Cc Matthew Brost <[email protected]>
Cc Chris Wilson <[email protected]>
Cc Tejas Upadhyay <[email protected]>
Cc Umesh Nerlige Ramappa <[email protected]>
Cc "Thomas Hellström" <[email protected]>
Cc Stuart Summers <[email protected]>
Cc Matthew Auld <[email protected]>
Cc Jani Nikula <[email protected]>
Cc Ramalingam C <[email protected]>
Cc Akeem G Abodunrin <[email protected]>
---
 drivers/gpu/drm/i915/gt/intel_engine_cs.c | 24 +++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)
drivers/gpu/drm/i915/gt/intel_engine_cs.c +12 -12
index 8f16955f0821e..fcbccd8d244e9 100644
@@ -486,6 +486,17 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id,
 	engine->logical_mask = BIT(logical_instance);
 	__sprint_engine_name(engine);
 
+	if ((engine->class == COMPUTE_CLASS && !RCS_MASK(engine->gt) &&
+	     __ffs(CCS_MASK(engine->gt)) == engine->instance) ||
+	     engine->class == RENDER_CLASS)
+		engine->flags |= I915_ENGINE_FIRST_RENDER_COMPUTE;
+
+	/* features common between engines sharing EUs */
+	if (engine->class == RENDER_CLASS || engine->class == COMPUTE_CLASS) {
+		engine->flags |= I915_ENGINE_HAS_RCS_REG_STATE;
+		engine->flags |= I915_ENGINE_HAS_EU_PRIORITY;
+	}
+
 	engine->props.heartbeat_interval_ms =
 		CONFIG_DRM_I915_HEARTBEAT_INTERVAL;
 	engine->props.max_busywait_duration_ns =
@@ -498,20 +509,9 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id,
 		CONFIG_DRM_I915_TIMESLICE_DURATION;
 
 	/* Override to uninterruptible for OpenCL workloads. */
-	if (GRAPHICS_VER(i915) == 12 && engine->class == RENDER_CLASS)
+	if (GRAPHICS_VER(i915) == 12 && (engine->flags & I915_ENGINE_HAS_RCS_REG_STATE))
 		engine->props.preempt_timeout_ms = 0;
 
-	if ((engine->class == COMPUTE_CLASS && !RCS_MASK(engine->gt) &&
-	     __ffs(CCS_MASK(engine->gt)) == engine->instance) ||
-	     engine->class == RENDER_CLASS)
-		engine->flags |= I915_ENGINE_FIRST_RENDER_COMPUTE;
-
-	/* features common between engines sharing EUs */
-	if (engine->class == RENDER_CLASS || engine->class == COMPUTE_CLASS) {
-		engine->flags |= I915_ENGINE_HAS_RCS_REG_STATE;
-		engine->flags |= I915_ENGINE_HAS_EU_PRIORITY;
-	}
-
 	/* Cap properties according to any system limits */
 #define CLAMP_PROP(field) \
 	do { \
Signature · 1 line
2.37.3
#4 lore raw

PATCH v4 3/4 drm/i915: Make the heartbeat play nice with long pre-emption timeouts

In reply to [email protected]

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
 .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +19 -0
index a3698f611f457..823a790a0e2ae 100644
@@ -22,9 +22,28 @@
 
 static bool next_heartbeat(struct intel_engine_cs *engine)
 {
+	struct i915_request *rq;
 	long delay;
 
 	delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+	rq = engine->heartbeat.systole;
+
+	if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+	    delay == engine->defaults.heartbeat_interval_ms) {
+		long longer;
+
+		/*
+		 * The final try is at the highest priority possible. Up until now
+		 * a pre-emption might not even have been attempted. So make sure
+		 * this last attempt allows enough time for a pre-emption to occur.
+		 */
+		longer = READ_ONCE(engine->props.preempt_timeout_ms) * 2;
+		longer = intel_clamp_heartbeat_interval_ms(engine, longer);
+		if (longer > delay)
+			delay = longer;
+	}
+
 	if (!delay)
 		return false;
 
Signature · 1 line
2.37.3
#5 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 35 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19 +++++++++++++++++++
  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +0 -0
index a3698f611f457..823a790a0e2ae 100644
@@ -22,9 +22,28 @@
 
  static bool next_heartbeat(struct intel_engine_cs *engine)

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 33

Quoted 10 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +6 -0
  {
+	struct i915_request *rq;
  	long delay;
 
  	delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+	rq = engine->heartbeat.systole;
+
+	if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+	    delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Regards,

Tvrtko

Quoted 16 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +13 -0
+		long longer;
+
+		/*
+		 * The final try is at the highest priority possible. Up until now
+		 * a pre-emption might not even have been attempted. So make sure
+		 * this last attempt allows enough time for a pre-emption to occur.
+		 */
+		longer = READ_ONCE(engine->props.preempt_timeout_ms) * 2;
+		longer = intel_clamp_heartbeat_interval_ms(engine, longer);
+		if (longer > delay)
+			delay = longer;
+	}
+
  	if (!delay)
  		return false;
 
#6 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 38 lines · Tvrtko Ursulin
Quoted 37 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19 +++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +1 -0
index a3698f611f457..823a790a0e2ae 100644
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
Quoted 8 lines

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 33

Quoted 6 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +5 -0
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

John.

Quoted 23 lines

Regards,

Tvrtko

Quoted 18 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +4 -0
+        long longer;
+
+        /*
+         * The final try is at the highest priority possible. Up 

until now
+         * a pre-emption might not even have been attempted. So make sure
+         * this last attempt allows enough time for a pre-emption to occur.
+         */
+        longer = READ_ONCE(engine->props.preempt_timeout_ms) * 2; +        longer = intel_clamp_heartbeat_interval_ms(engine, longer); +        if (longer > delay)
+            delay = longer;
+    }
+
      if (!delay)
          return false;

#7 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 47 lines · John Harrison
Quoted 38 lines · Tvrtko Ursulin
Quoted 37 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19 +++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +1 -0
index a3698f611f457..823a790a0e2ae 100644
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
Quoted 8 lines

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 33

Quoted 6 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +5 -0
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Quoted 1 line

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

Isn't this a bit too strict for the non-selftest case? If the new concept is extending the last pulse to guarantee preemption, then I think we could allow tweaking of the heartbeat period. Like what if user wants 1s, or 10s instead of 2.5s - why would that need to break the improvement from this patch?

In what ways selftests fail? Are they trying to guess time to reset based on the hearbeat period set? If so perhaps add a helper to query it based on the last pulse extension.

Regards,

Tvrtko

#8 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 49 lines · Tvrtko Ursulin
Quoted 48 lines · John Harrison
Quoted 47 lines · Tvrtko Ursulin
Quoted 34 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19
+++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +0 -0
index a3698f611f457..823a790a0e2ae 100644

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 31

Quoted 10 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +6 -0
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Quoted 3 lines
Quoted 1 line

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

Isn't this a bit too strict for the non-selftest case? If the new concept is extending the last pulse to guarantee preemption, then I think we could allow tweaking of the heartbeat period. Like what if user wants 1s, or 10s instead of 2.5s - why would that need to break the improvement from this patch?

Then the user is back to where they were before this patch.

Quoted 2 lines

In what ways selftests fail? Are they trying to guess time to reset based on the hearbeat period set? If so perhaps add a helper to query it based on the last pulse extension.

I don't recall. It was six months ago when I was actually working on this. And right now I do not have the time to go back and re-run all the testing and re-write a bunch of self tests with whole new helpers and algorithms and whatever else might be necessary to polish this to perfection. And in the meantime, all the existing issues are still present - there is no range checking on any of this stuff, it is very possible for a driver with default settings to break a legal workload because the heartbeat and pre-emption are fighting with each other, we don't even have per engine resets enabled, etc.

Maybe it could be even better with a follow up patch. Feel free to do that. But as it stands, this patch set significantly improves the situation without making anything worse.

John.

Quoted 4 lines

Regards,

Tvrtko

#9 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 53 lines · John Harrison
Quoted 49 lines · Tvrtko Ursulin
Quoted 48 lines · John Harrison
Quoted 47 lines · Tvrtko Ursulin
Quoted 34 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19
+++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +0 -0
index a3698f611f457..823a790a0e2ae 100644

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 31

Quoted 10 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +6 -0
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Quoted 3 lines
Quoted 1 line

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

Isn't this a bit too strict for the non-selftest case? If the new concept is extending the last pulse to guarantee preemption, then I think we could allow tweaking of the heartbeat period. Like what if user wants 1s, or 10s instead of 2.5s - why would that need to break the improvement from this patch?

Quoted 8 lines

Then the user is back to where they were before this patch.

Quoted 2 lines

In what ways selftests fail? Are they trying to guess time to reset based on the hearbeat period set? If so perhaps add a helper to query it based on the last pulse extension.

I don't recall. It was six months ago when I was actually working on this. And right now I do not have the time to go back and re-run all the testing and re-write a bunch of self tests with whole new helpers and algorithms and whatever else might be necessary to polish this to perfection. And in the meantime, all the existing issues are still present - there is no range checking on any of this stuff, it is very possible for a driver with default settings to break a legal workload because the heartbeat and pre-emption are fighting with each other, we don't even have per engine resets enabled, etc.

Maybe it could be even better with a follow up patch. Feel free to do that. But as it stands, this patch set significantly improves the situation without making anything worse.

As we seem to be in agreement that the check against default heartbeat is a hack with only purpose to work around assumptions made by selftests, then please file a Jira about removing it (this hack). Then work can be assigned to someone to clean it up. With that done I would agree the series is indeed an improvement and it would have my ack.

Regards,

Tvrtko

#10 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 58 lines · Tvrtko Ursulin
Quoted 56 lines · John Harrison
Quoted 49 lines · Tvrtko Ursulin
Quoted 48 lines · John Harrison
Quoted 47 lines · Tvrtko Ursulin
Quoted 34 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19
+++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +0 -0
index a3698f611f457..823a790a0e2ae 100644

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 31

Quoted 10 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +6 -0
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Quoted 3 lines
Quoted 1 line

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

Isn't this a bit too strict for the non-selftest case? If the new concept is extending the last pulse to guarantee preemption, then I think we could allow tweaking of the heartbeat period. Like what if user wants 1s, or 10s instead of 2.5s - why would that need to break the improvement from this patch?

Then the user is back to where they were before this patch.

Quoted 1 line
Quoted 7 lines
Quoted 5 lines
Quoted 1 line

In what ways selftests fail? Are they trying to guess time to reset based on the hearbeat period set? If so perhaps add a helper to query it based on the last pulse extension.

I don't recall. It was six months ago when I was actually working on this. And right now I do not have the time to go back and re-run all the testing and re-write a bunch of self tests with whole new helpers and algorithms and whatever else might be necessary to polish this to perfection. And in the meantime, all the existing issues are still present - there is no range checking on any of this stuff, it is very possible for a driver with default settings to break a legal workload because the heartbeat and pre-emption are fighting with each other, we don't even have per engine resets enabled, etc.

Maybe it could be even better with a follow up patch. Feel free to do that. But as it stands, this patch set significantly improves the situation without making anything worse.

As we seem to be in agreement that the check against default heartbeat is a hack with only purpose to work around assumptions made by selftests, then please file a Jira about removing it (this hack). Then work can be assigned to someone to clean it up. With that done I would agree the series is indeed an improvement and it would have my ack.

One more thing - put a comment in the code along the lines of "FIXME/HACK: Work around selftests assumptions by only extending the last heartbeat if the period is at default value". The the Jira can associate to that comment.

Until that is resolve it may also be worth emitting a drm_notice if heartbeat is changed via sysfs? Informing users the things will not work as expected if they fiddle with it. Whether as a blanket warning or checking first the 3-4x heartbeat vs preempt timeout value. That message should then go away once the follow up work to fix the selftests is done. See what the other reviewers will think.

Regards,

Tvrtko

#11 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 58 lines · Tvrtko Ursulin
Quoted 57 lines · Tvrtko Ursulin
Quoted 56 lines · John Harrison
Quoted 49 lines · Tvrtko Ursulin
Quoted 48 lines · John Harrison
Quoted 47 lines · Tvrtko Ursulin
Quoted 34 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19
+++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +0 -0
index a3698f611f457..823a790a0e2ae 100644

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 31

Quoted 10 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +6 -0
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Quoted 3 lines
Quoted 1 line

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

Isn't this a bit too strict for the non-selftest case? If the new concept is extending the last pulse to guarantee preemption, then I think we could allow tweaking of the heartbeat period. Like what if user wants 1s, or 10s instead of 2.5s - why would that need to break the improvement from this patch?

Then the user is back to where they were before this patch.

Quoted 1 line
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
Quoted 1 line

In what ways selftests fail? Are they trying to guess time to reset based on the hearbeat period set? If so perhaps add a helper to query it based on the last pulse extension.

I don't recall. It was six months ago when I was actually working on this. And right now I do not have the time to go back and re-run all the testing and re-write a bunch of self tests with whole new helpers and algorithms and whatever else might be necessary to polish this to perfection. And in the meantime, all the existing issues are still present - there is no range checking on any of this stuff, it is very possible for a driver with default settings to break a legal workload because the heartbeat and pre-emption are fighting with each other, we don't even have per engine resets enabled, etc.

Maybe it could be even better with a follow up patch. Feel free to do that. But as it stands, this patch set significantly improves the situation without making anything worse.

As we seem to be in agreement that the check against default heartbeat is a hack with only purpose to work around assumptions made by selftests, then please file a Jira about removing it (this hack). Then work can be assigned to someone to clean it up. With that done I would agree the series is indeed an improvement and it would have my ack.

VLK-39595

Quoted 5 lines

One more thing - put a comment in the code along the lines of "FIXME/HACK: Work around selftests assumptions by only extending the last heartbeat if the period is at default value". The the Jira can associate to that comment.

Until that is resolve it may also be worth emitting a drm_notice if heartbeat is changed via sysfs? Informing users the things will not work as expected if they fiddle with it. Whether as a blanket warning or checking first the 3-4x heartbeat vs preempt timeout value. That message should then go away once the follow up work to fix the selftests is done. See what the other reviewers will think.

What should the drm_notice say? How can you describe to an innocent end user what the symptoms might be in a single, concise line rather than the huge email thread that it took to explain to you, an experienced i915 kernel developer?

Is there a single end user out there that actually uses the sysfs interface for tuning these parameters? AFAIK, the usage is 99.999% IGT, the rest is internal developers debugging problems. Maybe someone somewhere has noticed them because they have a compute task that takes tens of seconds to complete. But the official guidance for compute users is to simply disable the heartbeat completely. We never tell anyone to try to tune the period or the pre-emption timeout to their specific application. That's just too complicated and unpredictable. We need defaults that work for the general case and for compute it is disabled. Manual tuning just isn't useful. Unless it's to reduce the stupidly high pre-emption timeout to get a more responsive desktop because they never actually need to run long compute tasks. And in that case, you don't need extended last periods because your pre-emption timeout is already massively smaller than the period.

John.

Quoted 3 lines

Regards,

Tvrtko

#12 lore raw

Re: [Intel-gfx] [PATCH v4 3/4] drm/i915: Make the heartbeat play nice with long pre-emption timeouts

Quoted 66 lines · John Harrison
Quoted 58 lines · Tvrtko Ursulin
Quoted 57 lines · Tvrtko Ursulin
Quoted 56 lines · John Harrison
Quoted 49 lines · Tvrtko Ursulin
Quoted 48 lines · John Harrison
Quoted 47 lines · Tvrtko Ursulin
Quoted 34 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

Compute workloads are inherently not pre-emptible for long periods on current hardware. As a workaround for this, the pre-emption timeout for compute capable engines was disabled. This is undesirable with GuC submission as it prevents per engine reset of hung contexts. Hence the next patch will re-enable the timeout but bumped up by an order of magnitude.

However, the heartbeat might not respect that. Depending upon current activity, a pre-emption to the heartbeat pulse might not even be attempted until the last heartbeat period. Which means that only one period is granted for the pre-emption to occur. With the aforesaid bump, the pre-emption timeout could be significantly larger than this heartbeat period.

So adjust the heartbeat code to take the pre-emption timeout into account. When it reaches the final (high priority) period, it now ensures the delay before hitting reset is bigger than the pre-emption timeout.

v2: Fix for selftests which adjust the heartbeat period manually.

---
  .../gpu/drm/i915/gt/intel_engine_heartbeat.c  | 19
+++++++++++++++++++

  1 file changed, 19 insertions(+)
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +0 -0
index a3698f611f457..823a790a0e2ae 100644

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c line 31

Quoted 10 lines
drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c +6 -0
@@ -22,9 +22,28 @@
     static bool next_heartbeat(struct intel_engine_cs *engine)
   {
+    struct i915_request *rq;
       long delay;
         delay = READ_ONCE(engine->props.heartbeat_interval_ms);
+
+    rq = engine->heartbeat.systole;
+
+    if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&
+        delay == engine->defaults.heartbeat_interval_ms) {

Maybe I forgot but what is the reason for the check against the default heartbeat interval?

Quoted 3 lines
Quoted 1 line

That's the 'v2: fix for selftests that manually adjust the heartbeat'. If something (or someone) has explicitly set an override of the heartbeat then it has to be assumed that they know what they are doing, and if things don't work any more that's their problem. But if we don't respect their override then they won't get the timings they expect and the selftest will fail.

Isn't this a bit too strict for the non-selftest case? If the new concept is extending the last pulse to guarantee preemption, then I think we could allow tweaking of the heartbeat period. Like what if user wants 1s, or 10s instead of 2.5s - why would that need to break the improvement from this patch?

Then the user is back to where they were before this patch.

Quoted 1 line
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
Quoted 1 line

In what ways selftests fail? Are they trying to guess time to reset based on the hearbeat period set? If so perhaps add a helper to query it based on the last pulse extension.

I don't recall. It was six months ago when I was actually working on this. And right now I do not have the time to go back and re-run all the testing and re-write a bunch of self tests with whole new helpers and algorithms and whatever else might be necessary to polish this to perfection. And in the meantime, all the existing issues are still present - there is no range checking on any of this stuff, it is very possible for a driver with default settings to break a legal workload because the heartbeat and pre-emption are fighting with each other, we don't even have per engine resets enabled, etc.

Maybe it could be even better with a follow up patch. Feel free to do that. But as it stands, this patch set significantly improves the situation without making anything worse.

As we seem to be in agreement that the check against default heartbeat is a hack with only purpose to work around assumptions made by selftests, then please file a Jira about removing it (this hack). Then work can be assigned to someone to clean it up. With that done I would agree the series is indeed an improvement and it would have my ack.

Quoted 8 lines

VLK-39595

Quoted 5 lines

One more thing - put a comment in the code along the lines of "FIXME/HACK: Work around selftests assumptions by only extending the last heartbeat if the period is at default value". The the Jira can associate to that comment.

Until that is resolve it may also be worth emitting a drm_notice if heartbeat is changed via sysfs? Informing users the things will not work as expected if they fiddle with it. Whether as a blanket warning or checking first the 3-4x heartbeat vs preempt timeout value. That message should then go away once the follow up work to fix the selftests is done. See what the other reviewers will think.

What should the drm_notice say? How can you describe to an innocent end user what the symptoms might be in a single, concise line rather than the huge email thread that it took to explain to you, an experienced i915 kernel developer?

I think what would be useful is to have something like:

sysfs_write, or was it a setter helper?:

/* FIXME: Remove together with equally marked hack in next_heartbeat. */ if (heartbeat != default && heartbeat < 2 * preempt_timeout) {
if (guc)
drm_note("%s heartbeat interval adjusted to a non-default value which
may downgrade individual engine resets to full GPU resets!\n", engine->name);
else
drm_note("%s heartbeat interval adjusted to a non-default value which
may cause engine resets to target innocent contexts!\n", engine->name); }

Sounds correct? Double preempt timeout or maybe 1.5x, not sure.

I do accept this is something which we could have had from the start (of heartbeats and preempt timeout), but now that this patch fixes the logic to extend the last pulse, apart from the selftests hack which limits it again, I think it is reasonable to add it in scope of this series.

Quoted 1 line

Is there a single end user out there that actually uses the sysfs interface for tuning these parameters? AFAIK, the usage is 99.999% IGT, the rest is internal developers debugging problems. Maybe someone somewhere has noticed them because they have a compute task that takes tens of seconds to complete. But the official guidance for compute users is to simply disable the heartbeat completely. We never tell anyone to try to tune the period or the pre-emption timeout to their specific application. That's just too complicated and unpredictable. We need defaults that work for the general case and for compute it is disabled. Manual tuning just isn't useful. Unless it's to reduce the stupidly high pre-emption timeout to get a more responsive desktop because they never actually need to run long compute tasks. And in that case, you don't need extended last periods because your pre-emption timeout is already massively smaller than the period.

Don't know if there are users but it's out there and it's ABI so I would err on the side of caution. It happened in the past that we were discussing how something is maybe not important and then with uncanny coincidence users immediately appear complaining about the very same thing.

Again, I do agree the patch is not making anything worse - on the contrary it is improving things in the default configuration. And as I think the principle of last pulse extension is the right approach it feels selftests are too weak of a reason to give up on it so easily.

Regards,

Tvrtko

#13 lore raw

PATCH v4 4/4 drm/i915: Improve long running compute w/a for GuC submission

In reply to [email protected]

From: John Harrison <[email protected]>

A workaround was added to the driver to allow compute workloads to run 'forever' by disabling pre-emption on the RCS engine for Gen12. It is not totally unbound as the heartbeat will kick in eventually and cause a reset of the hung engine.

However, this does not work well in GuC submission mode. In GuC mode, the pre-emption timeout is how GuC detects hung contexts and triggers a per engine reset. Thus, disabling the timeout means also losing all per engine reset ability. A full GT reset will still occur when the heartbeat finally expires, but that is a much more destructive and undesirable mechanism.

The purpose of the workaround is actually to give compute tasks longer to reach a pre-emption point after a pre-emption request has been issued. This is necessary because Gen12 does not support mid-thread pre-emption and compute tasks can have long running threads.

So, rather than disabling the timeout completely, just set it to a 'long' value.

v2: Review feedback from Tvrtko - must hard code the 'long' value instead of determining it algorithmically. So make it an extra CONFIG definition. Also, remove the execlist centric comment from the existing pre-emption timeout CONFIG option given that it applies to more than just execlists.

---
 drivers/gpu/drm/i915/Kconfig.profile      | 26 +++++++++++++++++++----
 drivers/gpu/drm/i915/gt/intel_engine_cs.c |  9 ++++++--
 2 files changed, 29 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/Kconfig.profile +22 -4
index 39328567c2007..7cc38d25ee5c8 100644
@@ -57,10 +57,28 @@ config DRM_I915_PREEMPT_TIMEOUT
 	default 640 # milliseconds
 	help
 	  How long to wait (in milliseconds) for a preemption event to occur
-	  when submitting a new context via execlists. If the current context
-	  does not hit an arbitration point and yield to HW before the timer
-	  expires, the HW will be reset to allow the more important context
-	  to execute.
+	  when submitting a new context. If the current context does not hit
+	  an arbitration point and yield to HW before the timer expires, the
+	  HW will be reset to allow the more important context to execute.
+
+	  This is adjustable via
+	  /sys/class/drm/card?/engine/*/preempt_timeout_ms
+
+	  May be 0 to disable the timeout.
+
+	  The compiled in default may get overridden at driver probe time on
+	  certain platforms and certain engines which will be reflected in the
+	  sysfs control.
+
+config DRM_I915_PREEMPT_TIMEOUT_COMPUTE
+	int "Preempt timeout for compute engines (ms, jiffy granularity)"
+	default 7500 # milliseconds
+	help
+	  How long to wait (in milliseconds) for a preemption event to occur
+	  when submitting a new context to a compute capable engine. If the
+	  current context does not hit an arbitration point and yield to HW
+	  before the timer expires, the HW will be reset to allow the more
+	  important context to execute.
 
 	  This is adjustable via
 	  /sys/class/drm/card?/engine/*/preempt_timeout_ms
drivers/gpu/drm/i915/gt/intel_engine_cs.c +7 -2
index fcbccd8d244e9..c1257723d1949 100644
@@ -508,9 +508,14 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id,
 	engine->props.timeslice_duration_ms =
 		CONFIG_DRM_I915_TIMESLICE_DURATION;
 
-	/* Override to uninterruptible for OpenCL workloads. */
+	/*
+	 * Mid-thread pre-emption is not available in Gen12. Unfortunately,
+	 * some compute workloads run quite long threads. That means they get
+	 * reset due to not pre-empting in a timely manner. So, bump the
+	 * pre-emption timeout value to be much higher for compute engines.
+	 */
 	if (GRAPHICS_VER(i915) == 12 && (engine->flags & I915_ENGINE_HAS_RCS_REG_STATE))
-		engine->props.preempt_timeout_ms = 0;
+		engine->props.preempt_timeout_ms = CONFIG_DRM_I915_PREEMPT_TIMEOUT_COMPUTE;
 
 	/* Cap properties according to any system limits */
 #define CLAMP_PROP(field) \
Signature · 1 line
2.37.3
Acked-by on v4 4/4
#14 lore raw

Re: [Intel-gfx] [PATCH v4 4/4] drm/i915: Improve long running compute w/a for GuC submission

Quoted 28 lines · On 29/09/2022 03:18, [email protected] wrote:

From: John Harrison <[email protected]>

A workaround was added to the driver to allow compute workloads to run 'forever' by disabling pre-emption on the RCS engine for Gen12. It is not totally unbound as the heartbeat will kick in eventually and cause a reset of the hung engine.

However, this does not work well in GuC submission mode. In GuC mode, the pre-emption timeout is how GuC detects hung contexts and triggers a per engine reset. Thus, disabling the timeout means also losing all per engine reset ability. A full GT reset will still occur when the heartbeat finally expires, but that is a much more destructive and undesirable mechanism.

The purpose of the workaround is actually to give compute tasks longer to reach a pre-emption point after a pre-emption request has been issued. This is necessary because Gen12 does not support mid-thread pre-emption and compute tasks can have long running threads.

So, rather than disabling the timeout completely, just set it to a 'long' value.

v2: Review feedback from Tvrtko - must hard code the 'long' value instead of determining it algorithmically. So make it an extra CONFIG definition. Also, remove the execlist centric comment from the existing pre-emption timeout CONFIG option given that it applies to more than just execlists.

Quoted 3 lines

Regards,

Tvrtko

Quoted 63 lines
---
  drivers/gpu/drm/i915/Kconfig.profile      | 26 +++++++++++++++++++----
  drivers/gpu/drm/i915/gt/intel_engine_cs.c |  9 ++++++--
  2 files changed, 29 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/Kconfig.profile +22 -4
index 39328567c2007..7cc38d25ee5c8 100644
@@ -57,10 +57,28 @@ config DRM_I915_PREEMPT_TIMEOUT
  	default 640 # milliseconds
  	help
  	  How long to wait (in milliseconds) for a preemption event to occur
-	  when submitting a new context via execlists. If the current context
-	  does not hit an arbitration point and yield to HW before the timer
-	  expires, the HW will be reset to allow the more important context
-	  to execute.
+	  when submitting a new context. If the current context does not hit
+	  an arbitration point and yield to HW before the timer expires, the
+	  HW will be reset to allow the more important context to execute.
+
+	  This is adjustable via
+	  /sys/class/drm/card?/engine/*/preempt_timeout_ms
+
+	  May be 0 to disable the timeout.
+
+	  The compiled in default may get overridden at driver probe time on
+	  certain platforms and certain engines which will be reflected in the
+	  sysfs control.
+
+config DRM_I915_PREEMPT_TIMEOUT_COMPUTE
+	int "Preempt timeout for compute engines (ms, jiffy granularity)"
+	default 7500 # milliseconds
+	help
+	  How long to wait (in milliseconds) for a preemption event to occur
+	  when submitting a new context to a compute capable engine. If the
+	  current context does not hit an arbitration point and yield to HW
+	  before the timer expires, the HW will be reset to allow the more
+	  important context to execute.
 
  	  This is adjustable via
  	  /sys/class/drm/card?/engine/*/preempt_timeout_ms
drivers/gpu/drm/i915/gt/intel_engine_cs.c +7 -2
index fcbccd8d244e9..c1257723d1949 100644
@@ -508,9 +508,14 @@ static int intel_engine_setup(struct intel_gt *gt, enum intel_engine_id id,
  	engine->props.timeslice_duration_ms =
  		CONFIG_DRM_I915_TIMESLICE_DURATION;
 
-	/* Override to uninterruptible for OpenCL workloads. */
+	/*
+	 * Mid-thread pre-emption is not available in Gen12. Unfortunately,
+	 * some compute workloads run quite long threads. That means they get
+	 * reset due to not pre-empting in a timely manner. So, bump the
+	 * pre-emption timeout value to be much higher for compute engines.
+	 */
  	if (GRAPHICS_VER(i915) == 12 && (engine->flags & I915_ENGINE_HAS_RCS_REG_STATE))
-		engine->props.preempt_timeout_ms = 0;
+		engine->props.preempt_timeout_ms = CONFIG_DRM_I915_PREEMPT_TIMEOUT_COMPUTE;
 
  	/* Cap properties according to any system limits */
  #define CLAMP_PROP(field) \
#15 lore raw

[Intel-gfx] ✗ Fi.CI.CHECKPATCH: warning for Improve anti-pre-emption w/a for compute workloads (rev7)

In reply to [email protected]
== Series Details ==

== Series Details ==

Series: Improve anti-pre-emption w/a for compute workloads (rev7)
URL : https://patchwork.freedesktop.org/series/100428/
State : warning

== Summary ==

Error: dim checkpatch failed
502f12c04cdf drm/i915/guc: Limit scheduling properties to avoid overflow -:44: CHECK:MACRO_ARG_REUSE: Macro argument reuse 'field' - possible side-effects? #44: FILE: drivers/gpu/drm/i915/gt/intel_engine_cs.c:516:
+#define CLAMP_PROP(field) \
+ do { \
+ u64 clamp = intel_clamp_##field(engine, engine->props.field); \
+ if (clamp != engine->props.field) { \
+ drm_notice(&engine->i915->drm, \
+ "Warning, clamping %s to %lld to prevent overflow\n", \
+ #field, clamp); \
+ engine->props.field = clamp; \
+ } \
+ } while (0)

total: 0 errors, 0 warnings, 1 checks, 223 lines checked
29c47abff7df drm/i915: Fix compute pre-emption w/a to apply to compute engines 911b8d3394fd drm/i915: Make the heartbeat play nice with long pre-emption timeouts 3924354f431a drm/i915: Improve long running compute w/a for GuC submission

#17 lore raw

[Intel-gfx] ✓ Fi.CI.BAT: success for Improve anti-pre-emption w/a for compute workloads (rev7)

In reply to [email protected]
== Series Details ==

== Series Details ==

Series: Improve anti-pre-emption w/a for compute workloads (rev7)
URL : https://patchwork.freedesktop.org/series/100428/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_12197 -> Patchwork_100428v7
====================================================

Summary
-------

**SUCCESS**

No regressions found.

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

Participating hosts (45 -> 45)
------------------------------

Additional (2): fi-rkl-guc fi-tgl-dsi
Missing (2): fi-icl-u2 fi-bdw-samus

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

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

### IGT changes ###

#### Issues hit ####

* igt@gem_lmem_swapping@basic:
- fi-rkl-guc: NOTRUN -> [SKIP][1] ([i915#4613]) +3 similar issues
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@gem_tiled_pread_basic:
- fi-rkl-guc: NOTRUN -> [SKIP][2] ([i915#3282])
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@gem_tiled_pread_basic.html

* igt@i915_pm_backlight@basic-brightness:
- fi-rkl-guc: NOTRUN -> [SKIP][3] ([i915#3012])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@i915_pm_rps@basic-api:
- fi-rkl-guc: NOTRUN -> [SKIP][4] ([i915#6621])
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@kms_chamelium@common-hpd-after-suspend:
- fi-hsw-4770: NOTRUN -> [SKIP][5] ([fdo#109271] / [fdo#111827])
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-hsw-4770/igt@[email protected]
- bat-dg1-5: NOTRUN -> [SKIP][6] ([fdo#111827])
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/bat-dg1-5/igt@[email protected]

* igt@kms_chamelium@hdmi-crc-fast:
- fi-rkl-guc: NOTRUN -> [SKIP][7] ([fdo#111827]) +8 similar issues
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@kms_cursor_legacy@basic-busy-flip-before-cursor:
- fi-rkl-guc: NOTRUN -> [SKIP][8] ([i915#4103])
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@kms_force_connector_basic@force-load-detect:
- fi-rkl-guc: NOTRUN -> [SKIP][9] ([fdo#109285])
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@kms_pipe_crc_basic@suspend-read-crc:
- bat-dg1-5: NOTRUN -> [SKIP][10] ([i915#4078])
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/bat-dg1-5/igt@[email protected]

* igt@kms_psr@sprite_plane_onoff:
- fi-rkl-guc: NOTRUN -> [SKIP][11] ([i915#1072]) +3 similar issues
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@kms_psr@sprite_plane_onoff.html

* igt@kms_setmode@basic-clone-single-crtc:
- fi-rkl-guc: NOTRUN -> [SKIP][12] ([i915#3555] / [i915#4098])
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@prime_vgem@basic-userptr:
- fi-rkl-guc: NOTRUN -> [SKIP][13] ([fdo#109295] / [i915#3301] / [i915#3708])
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

* igt@prime_vgem@basic-write:
- fi-rkl-guc: NOTRUN -> [SKIP][14] ([fdo#109295] / [i915#3291] / [i915#3708]) +2 similar issues
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-rkl-guc/igt@[email protected]

#### Possible fixes ####

* igt@i915_selftest@live@gt_engines:
- bat-dg1-5: [INCOMPLETE][15] ([i915#4418]) -> [PASS][16]
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/bat-dg1-5/igt@i915_selftest@live@gt_engines.html
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/bat-dg1-5/igt@i915_selftest@live@gt_engines.html

* igt@i915_selftest@live@hangcheck:
- fi-hsw-4770: [INCOMPLETE][17] ([i915#4785]) -> [PASS][18]
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/fi-hsw-4770/igt@i915_selftest@[email protected]
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/fi-hsw-4770/igt@i915_selftest@[email protected]

* igt@kms_pipe_crc_basic@suspend-read-crc@pipe-d-dp-2:
- {bat-dg2-11}: [FAIL][19] ([i915#6818]) -> [PASS][20]
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/bat-dg2-11/igt@kms_pipe_crc_basic@[email protected]
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/bat-dg2-11/igt@kms_pipe_crc_basic@[email protected]

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

[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[fdo#109284]: https://bugs.freedesktop.org/show_bug.cgi?id=109284
[fdo#109285]: https://bugs.freedesktop.org/show_bug.cgi?id=109285
[fdo#109295]: https://bugs.freedesktop.org/show_bug.cgi?id=109295
[fdo#110189]: https://bugs.freedesktop.org/show_bug.cgi?id=110189
[fdo#111827]: https://bugs.freedesktop.org/show_bug.cgi?id=111827
[i915#1072]: https://gitlab.freedesktop.org/drm/intel/issues/1072
[i915#1759]: https://gitlab.freedesktop.org/drm/intel/issues/1759
[i915#2190]: https://gitlab.freedesktop.org/drm/intel/issues/2190
[i915#3012]: https://gitlab.freedesktop.org/drm/intel/issues/3012
[i915#3282]: https://gitlab.freedesktop.org/drm/intel/issues/3282
[i915#3291]: https://gitlab.freedesktop.org/drm/intel/issues/3291
[i915#3301]: https://gitlab.freedesktop.org/drm/intel/issues/3301
[i915#3555]: https://gitlab.freedesktop.org/drm/intel/issues/3555
[i915#3708]: https://gitlab.freedesktop.org/drm/intel/issues/3708
[i915#4078]: https://gitlab.freedesktop.org/drm/intel/issues/4078
[i915#4098]: https://gitlab.freedesktop.org/drm/intel/issues/4098
[i915#4103]: https://gitlab.freedesktop.org/drm/intel/issues/4103
[i915#4418]: https://gitlab.freedesktop.org/drm/intel/issues/4418
[i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
[i915#4785]: https://gitlab.freedesktop.org/drm/intel/issues/4785
[i915#4983]: https://gitlab.freedesktop.org/drm/intel/issues/4983
[i915#6257]: https://gitlab.freedesktop.org/drm/intel/issues/6257
[i915#6621]: https://gitlab.freedesktop.org/drm/intel/issues/6621
[i915#6818]: https://gitlab.freedesktop.org/drm/intel/issues/6818

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

* Linux: CI_DRM_12197 -> Patchwork_100428v7

CI-20190529: 20190529
CI_DRM_12197: cafa326de8e7860d45639e61bf66ec9c218207b1 @ git://anongit.freedesktop.org/gfx-ci/linux
IGT_6668: 5f29c9369550164b35b65baaaeba4b370f434cf1 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
Patchwork_100428v7: cafa326de8e7860d45639e61bf66ec9c218207b1 @ git://anongit.freedesktop.org/gfx-ci/linux

### Linux commits

ba8ed6dce4ac drm/i915: Improve long running compute w/a for GuC submission 926b41b6a3f9 drm/i915: Make the heartbeat play nice with long pre-emption timeouts 694fc8b24e46 drm/i915: Fix compute pre-emption w/a to apply to compute engines e6c0bb5057c0 drm/i915/guc: Limit scheduling properties to avoid overflow

== Logs ==

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

#18 lore raw

[Intel-gfx] ✓ Fi.CI.IGT: success for Improve anti-pre-emption w/a for compute workloads (rev7)

In reply to [email protected]
== Series Details ==

== Series Details ==

Series: Improve anti-pre-emption w/a for compute workloads (rev7)
URL : https://patchwork.freedesktop.org/series/100428/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_12197_full -> Patchwork_100428v7_full
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (12 -> 12)
------------------------------

No changes in participating hosts

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

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

### IGT changes ###

#### Suppressed ####

The following results come from untrusted machines, tests, or statuses. They do not affect the overall result.

* igt@i915_module_load@resize-bar:
- {shard-dg1}: [FAIL][1] ([i915#6458]) -> [DMESG-FAIL][2]
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-dg1-19/igt@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-dg1-18/igt@[email protected]

* igt@kms_cursor_legacy@single-move@pipe-c:
- {shard-rkl}: [PASS][3] -> [INCOMPLETE][4]
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-4/igt@kms_cursor_legacy@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-3/igt@kms_cursor_legacy@[email protected]

* {igt@kms_plane_alpha_blend@alpha-transparent-fb}:
- {shard-rkl}: NOTRUN -> [SKIP][5]
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-3/igt@[email protected]

* igt@kms_rotation_crc@primary-rotation-270:
- {shard-rkl}: [SKIP][6] ([i915#1845] / [i915#4098]) -> [INCOMPLETE][7]
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-2/igt@[email protected]
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-6/igt@[email protected]

* igt@sysfs_preempt_timeout@idempotent@rcs0:
- {shard-dg1}: [PASS][8] -> [FAIL][9] +4 similar issues
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-dg1-16/igt@sysfs_preempt_timeout@[email protected]
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-dg1-15/igt@sysfs_preempt_timeout@[email protected]

New tests
---------

New tests have been introduced between CI_DRM_12197_full and Patchwork_100428v7_full:

### New IGT tests (4) ###

* igt@kms_plane_alpha_blend@constant-alpha-max@pipe-a-hdmi-a-3:
- Statuses : 1 pass(s)
- Exec time: [2.85] s

* igt@kms_plane_alpha_blend@constant-alpha-max@pipe-b-hdmi-a-3:
- Statuses : 1 pass(s)
- Exec time: [2.86] s

* igt@kms_plane_alpha_blend@constant-alpha-max@pipe-c-hdmi-a-3:
- Statuses : 1 pass(s)
- Exec time: [2.88] s

* igt@kms_plane_alpha_blend@constant-alpha-max@pipe-d-hdmi-a-3:
- Statuses : 1 pass(s)
- Exec time: [2.86] s

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

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

### CI changes ###

#### Issues hit ####

* boot:
- shard-snb: ([PASS][10], [PASS][11], [PASS][12], [PASS][13], [PASS][14], [PASS][15], [PASS][16], [PASS][17], [PASS][18], [PASS][19], [PASS][20], [PASS][21], [PASS][22], [PASS][23], [PASS][24], [PASS][25], [PASS][26], [PASS][27], [PASS][28], [PASS][29], [PASS][30], [PASS][31], [PASS][32], [PASS][33], [PASS][34]) -> ([PASS][35], [PASS][36], [PASS][37], [PASS][38], [PASS][39], [PASS][40], [PASS][41], [FAIL][42], [FAIL][43], [PASS][44], [PASS][45], [PASS][46], [PASS][47], [PASS][48], [PASS][49], [PASS][50], [PASS][51], [PASS][52], [PASS][53], [PASS][54], [PASS][55], [PASS][56], [PASS][57], [PASS][58], [PASS][59]) ([i915#4338])
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb7/boot.html
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb7/boot.html
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb7/boot.html
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb7/boot.html
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb6/boot.html
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb6/boot.html
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb6/boot.html
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb6/boot.html
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb6/boot.html
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb6/boot.html
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb5/boot.html
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb5/boot.html
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb5/boot.html
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb5/boot.html
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb5/boot.html
[25]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb4/boot.html
[26]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb4/boot.html
[27]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb4/boot.html
[28]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb4/boot.html
[29]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb4/boot.html
[30]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb2/boot.html
[31]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb2/boot.html
[32]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb2/boot.html
[33]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb2/boot.html
[34]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb2/boot.html
[35]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb7/boot.html
[36]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb7/boot.html
[37]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb7/boot.html
[38]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb7/boot.html
[39]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb7/boot.html
[40]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb6/boot.html
[41]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb6/boot.html
[42]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb6/boot.html
[43]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb6/boot.html
[44]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb6/boot.html
[45]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb6/boot.html
[46]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb5/boot.html
[47]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb5/boot.html
[48]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb5/boot.html
[49]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb5/boot.html
[50]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb5/boot.html
[51]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb4/boot.html
[52]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb4/boot.html
[53]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb4/boot.html
[54]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb4/boot.html
[55]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb4/boot.html
[56]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb2/boot.html
[57]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb2/boot.html
[58]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb2/boot.html
[59]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb2/boot.html

#### Possible fixes ####

* boot:
- shard-glk: ([PASS][60], [PASS][61], [PASS][62], [PASS][63], [PASS][64], [PASS][65], [PASS][66], [PASS][67], [PASS][68], [PASS][69], [PASS][70], [PASS][71], [PASS][72], [PASS][73], [PASS][74], [FAIL][75], [PASS][76], [PASS][77], [PASS][78], [PASS][79], [PASS][80], [PASS][81], [PASS][82], [PASS][83], [PASS][84]) ([i915#4392]) -> ([PASS][85], [PASS][86], [PASS][87], [PASS][88], [PASS][89], [PASS][90], [PASS][91], [PASS][92], [PASS][93], [PASS][94], [PASS][95], [PASS][96], [PASS][97], [PASS][98], [PASS][99], [PASS][100], [PASS][101], [PASS][102], [PASS][103], [PASS][104], [PASS][105], [PASS][106], [PASS][107], [PASS][108], [PASS][109])
[60]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk9/boot.html
[61]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk9/boot.html
[62]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk9/boot.html
[63]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk8/boot.html
[64]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk8/boot.html
[65]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk8/boot.html
[66]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk7/boot.html
[67]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk7/boot.html
[68]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk7/boot.html
[69]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk6/boot.html
[70]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk6/boot.html
[71]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk6/boot.html
[72]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk5/boot.html
[73]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk5/boot.html
[74]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk5/boot.html
[75]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk3/boot.html
[76]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk3/boot.html
[77]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk3/boot.html
[78]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk3/boot.html
[79]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk2/boot.html
[80]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk2/boot.html
[81]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk2/boot.html
[82]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk1/boot.html
[83]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk1/boot.html
[84]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk1/boot.html
[85]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk9/boot.html
[86]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk9/boot.html
[87]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk9/boot.html
[88]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk8/boot.html
[89]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk8/boot.html
[90]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk8/boot.html
[91]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk7/boot.html
[92]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk7/boot.html
[93]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk7/boot.html
[94]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/boot.html
[95]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/boot.html
[96]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/boot.html
[97]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/boot.html
[98]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk5/boot.html
[99]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk5/boot.html
[100]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk5/boot.html
[101]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk3/boot.html
[102]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk3/boot.html
[103]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk3/boot.html
[104]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk2/boot.html
[105]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk2/boot.html
[106]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk2/boot.html
[107]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk1/boot.html
[108]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk1/boot.html
[109]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk1/boot.html

### IGT changes ###

#### Issues hit ####

* igt@gem_ctx_persistence@smoketest:
- shard-apl: [PASS][110] -> [FAIL][111] ([i915#5099])
[110]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl8/igt@[email protected]
[111]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl1/igt@[email protected]

* igt@gem_exec_balancer@parallel-keep-in-fence:
- shard-iclb: [PASS][112] -> [SKIP][113] ([i915#4525]) +1 similar issue
[112]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb4/igt@[email protected]
[113]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb6/igt@[email protected]

* igt@gem_exec_fair@basic-none-share@rcs0:
- shard-iclb: [PASS][114] -> [FAIL][115] ([i915#2842])
[114]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb4/igt@gem_exec_fair@[email protected]
[115]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb6/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-none-solo@rcs0:
- shard-apl: [PASS][116] -> [FAIL][117] ([i915#2842])
[116]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl3/igt@gem_exec_fair@[email protected]
[117]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-pace-share@rcs0:
- shard-glk: [PASS][118] -> [FAIL][119] ([i915#2842])
[118]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk8/igt@gem_exec_fair@[email protected]
[119]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk1/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-pace@vcs1:
- shard-iclb: NOTRUN -> [FAIL][120] ([i915#2842])
[120]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb4/igt@gem_exec_fair@[email protected]

* igt@gem_lmem_swapping@basic:
- shard-glk: NOTRUN -> [SKIP][121] ([fdo#109271] / [i915#4613])
[121]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/igt@[email protected]

* igt@gem_lmem_swapping@massive-random:
- shard-apl: NOTRUN -> [SKIP][122] ([fdo#109271] / [i915#4613])
[122]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@[email protected]

* igt@gem_mmap_offset@clear@smem0:
- shard-snb: [PASS][123] -> [FAIL][124] ([i915#6973])
[123]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-snb4/igt@gem_mmap_offset@[email protected]
[124]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-snb4/igt@gem_mmap_offset@[email protected]

* igt@gen9_exec_parse@allowed-single:
- shard-apl: [PASS][125] -> [DMESG-WARN][126] ([i915#5566] / [i915#716])
[125]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl1/igt@[email protected]
[126]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl6/igt@[email protected]

* igt@i915_selftest@live@hangcheck:
- shard-tglb: [PASS][127] -> [DMESG-WARN][128] ([i915#5591])
[127]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-tglb8/igt@i915_selftest@[email protected]
[128]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-tglb2/igt@i915_selftest@[email protected]

* igt@i915_suspend@fence-restore-tiled2untiled:
- shard-apl: [PASS][129] -> [DMESG-WARN][130] ([i915#180]) +5 similar issues
[129]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl3/igt@[email protected]
[130]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@[email protected]

* igt@kms_ccs@pipe-a-bad-aux-stride-y_tiled_gen12_rc_ccs_cc:
- shard-glk: NOTRUN -> [SKIP][131] ([fdo#109271] / [i915#3886]) +3 similar issues
[131]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/igt@kms_ccs@pipe-a-bad-aux-stride-y_tiled_gen12_rc_ccs_cc.html

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

* igt@kms_ccs@pipe-c-bad-rotation-90-y_tiled_gen12_rc_ccs:
- shard-glk: NOTRUN -> [SKIP][133] ([fdo#109271]) +44 similar issues
[133]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/igt@kms_ccs@pipe-c-bad-rotation-90-y_tiled_gen12_rc_ccs.html

* igt@kms_chamelium@hdmi-hpd-after-suspend:
- shard-glk: NOTRUN -> [SKIP][134] ([fdo#109271] / [fdo#111827]) +1 similar issue
[134]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/igt@[email protected]

* igt@kms_chamelium@vga-hpd-after-suspend:
- shard-apl: NOTRUN -> [SKIP][135] ([fdo#109271] / [fdo#111827]) +6 similar issues
[135]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl7/igt@[email protected]

* igt@kms_content_protection@uevent:
- shard-apl: NOTRUN -> [FAIL][136] ([i915#2105])
[136]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl7/igt@[email protected]

* igt@kms_fbcon_fbt@fbc-suspend:
- shard-apl: [PASS][137] -> [INCOMPLETE][138] ([i915#180] / [i915#1982] / [i915#4939])
[137]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl7/igt@[email protected]
[138]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl6/igt@[email protected]

* igt@kms_flip@2x-nonexisting-fb:
- shard-apl: NOTRUN -> [SKIP][139] ([fdo#109271]) +119 similar issues
[139]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl3/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank@c-hdmi-a1:
- shard-glk: [PASS][140] -> [FAIL][141] ([i915#79])
[140]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk9/igt@kms_flip@[email protected]
[141]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk9/igt@kms_flip@[email protected]

* igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-upscaling@pipe-a-default-mode:
- shard-iclb: NOTRUN -> [SKIP][142] ([i915#2672]) +3 similar issues
[142]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb2/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-upscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-upscaling@pipe-a-valid-mode:
- shard-iclb: NOTRUN -> [SKIP][143] ([i915#2587] / [i915#2672]) +3 similar issues
[143]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb7/igt@kms_flip_scaled_crc@[email protected]

* igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-5@pipe-c-edp-1:
- shard-iclb: [PASS][144] -> [SKIP][145] ([i915#5235]) +2 similar issues
[144]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb7/igt@kms_plane_scaling@[email protected]
[145]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb2/igt@kms_plane_scaling@[email protected]

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

* igt@kms_psr2_su@page_flip-xrgb8888:
- shard-iclb: [PASS][147] -> [SKIP][148] ([fdo#109642] / [fdo#111068] / [i915#658])
[147]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb2/igt@kms_psr2_su@page_flip-xrgb8888.html
[148]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb7/igt@kms_psr2_su@page_flip-xrgb8888.html
- shard-apl: NOTRUN -> [SKIP][149] ([fdo#109271] / [i915#658])
[149]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@kms_psr2_su@page_flip-xrgb8888.html

* igt@kms_psr@psr2_primary_page_flip:
- shard-iclb: [PASS][150] -> [SKIP][151] ([fdo#109441]) +1 similar issue
[150]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb2/igt@kms_psr@psr2_primary_page_flip.html
[151]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb7/igt@kms_psr@psr2_primary_page_flip.html

* igt@kms_vblank@pipe-d-wait-idle:
- shard-apl: NOTRUN -> [SKIP][152] ([fdo#109271] / [i915#533])
[152]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl7/igt@[email protected]

* igt@kms_writeback@writeback-invalid-parameters:
- shard-glk: NOTRUN -> [SKIP][153] ([fdo#109271] / [i915#2437])
[153]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk6/igt@[email protected]

#### Possible fixes ####

* igt@gem_ctx_exec@basic-nohangcheck:
- shard-tglb: [FAIL][154] ([i915#6268]) -> [PASS][155]
[154]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-tglb7/igt@[email protected]
[155]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-tglb5/igt@[email protected]

* igt@gem_ctx_persistence@hostile:
- {shard-dg1}: [FAIL][156] ([i915#4883]) -> [PASS][157]
[156]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-dg1-17/igt@[email protected]
[157]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-dg1-12/igt@[email protected]

* igt@gem_ctx_persistence@legacy-engines-hang@blt:
- {shard-rkl}: [SKIP][158] ([i915#6252]) -> [PASS][159]
[158]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-5/igt@gem_ctx_persistence@[email protected]
[159]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-1/igt@gem_ctx_persistence@[email protected]

* igt@gem_exec_endless@dispatch@bcs0:
- {shard-rkl}: [SKIP][160] ([i915#6247]) -> [PASS][161]
[160]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-5/igt@gem_exec_endless@[email protected]
[161]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-4/igt@gem_exec_endless@[email protected]

* igt@gem_exec_fair@basic-pace-share@rcs0:
- shard-tglb: [FAIL][162] ([i915#2842]) -> [PASS][163]
[162]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-tglb2/igt@gem_exec_fair@[email protected]
[163]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-tglb8/igt@gem_exec_fair@[email protected]

* igt@gem_exec_flush@basic-batch-kernel-default-cmd:
- {shard-rkl}: [SKIP][164] ([fdo#109313]) -> [PASS][165]
[164]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-2/igt@[email protected]
[165]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-5/igt@[email protected]

* igt@gem_exec_reloc@basic-gtt-read-noreloc:
- {shard-rkl}: [SKIP][166] ([i915#3281]) -> [PASS][167] +9 similar issues
[166]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-2/igt@[email protected]
[167]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-5/igt@[email protected]

* igt@gem_partial_pwrite_pread@writes-after-reads:
- {shard-rkl}: [SKIP][168] ([i915#3282]) -> [PASS][169] +4 similar issues
[168]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-2/igt@[email protected]
[169]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-5/igt@[email protected]

* igt@gem_ppgtt@blt-vs-render-ctx0:
- {shard-rkl}: [DMESG-FAIL][170] ([i915#3692]) -> [PASS][171]
[170]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-5/igt@[email protected]
[171]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-1/igt@[email protected]

* igt@gem_ppgtt@blt-vs-render-ctxn:
- {shard-rkl}: [FAIL][172] ([i915#4998] / [i915#6778]) -> [PASS][173]
[172]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-5/igt@[email protected]
[173]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-4/igt@[email protected]

* igt@gen9_exec_parse@allowed-all:
- shard-glk: [DMESG-WARN][174] ([i915#5566] / [i915#716]) -> [PASS][175]
[174]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-glk5/igt@[email protected]
[175]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-glk2/igt@[email protected]

* igt@gen9_exec_parse@secure-batches:
- {shard-rkl}: [SKIP][176] ([i915#2527]) -> [PASS][177] +1 similar issue
[176]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-2/igt@[email protected]
[177]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-5/igt@[email protected]

* igt@i915_hangman@engine-engine-error@bcs0:
- {shard-rkl}: [SKIP][178] ([i915#6258]) -> [PASS][179]
[178]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-5/igt@i915_hangman@[email protected]
[179]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-1/igt@i915_hangman@[email protected]

* igt@i915_pm_dc@dc9-dpms:
- {shard-rkl}: [SKIP][180] ([i915#3361]) -> [PASS][181]
[180]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-5/igt@[email protected]
[181]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-4/igt@[email protected]

* igt@i915_suspend@sysfs-reader:
- shard-apl: [DMESG-WARN][182] ([i915#180]) -> [PASS][183] +3 similar issues
[182]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl6/igt@[email protected]
[183]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@[email protected]

* igt@kms_dp_aux_dev:
- {shard-rkl}: [SKIP][184] ([i915#1257]) -> [PASS][185]
[184]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-1/igt@kms_dp_aux_dev.html
[185]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-6/igt@kms_dp_aux_dev.html

* igt@kms_fbcon_fbt@fbc-suspend:
- {shard-tglu}: [FAIL][186] ([i915#4767]) -> [PASS][187]
[186]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-tglu-4/igt@[email protected]
[187]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-tglu-5/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank@b-dp1:
- shard-apl: [FAIL][188] ([i915#79]) -> [PASS][189] +1 similar issue
[188]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl2/igt@kms_flip@[email protected]
[189]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl8/igt@kms_flip@[email protected]

* igt@kms_frontbuffer_tracking@fbc-rgb101010-draw-pwrite:
- {shard-rkl}: [SKIP][190] ([i915#1849] / [i915#4098]) -> [PASS][191] +4 similar issues
[190]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-1/igt@[email protected]
[191]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-6/igt@[email protected]

* igt@kms_plane@plane-panning-bottom-right-suspend@pipe-a-planes:
- {shard-rkl}: [SKIP][192] ([i915#3558]) -> [PASS][193] +1 similar issue
[192]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-1/igt@kms_plane@[email protected]
[193]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-6/igt@kms_plane@[email protected]

* igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-pixel-formats@pipe-b-edp-1:
- shard-iclb: [SKIP][194] ([i915#5176]) -> [PASS][195] +1 similar issue
[194]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb3/igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-pixel-formats@pipe-b-edp-1.html
[195]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb4/igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-pixel-formats@pipe-b-edp-1.html

* igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5@pipe-a-edp-1:
- shard-iclb: [SKIP][196] ([i915#5235]) -> [PASS][197] +2 similar issues
[196]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb2/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5@pipe-a-edp-1.html
[197]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb7/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5@pipe-a-edp-1.html

* igt@kms_psr@cursor_render:
- {shard-rkl}: [SKIP][198] ([i915#1072]) -> [PASS][199]
[198]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-1/igt@kms_psr@cursor_render.html
[199]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-6/igt@kms_psr@cursor_render.html

* igt@kms_psr@psr2_no_drrs:
- shard-iclb: [SKIP][200] ([fdo#109441]) -> [PASS][201] +1 similar issue
[200]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb1/igt@kms_psr@psr2_no_drrs.html
[201]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb2/igt@kms_psr@psr2_no_drrs.html

* igt@kms_rotation_crc@primary-rotation-90:
- {shard-rkl}: [SKIP][202] ([i915#1845] / [i915#4098]) -> [PASS][203] +7 similar issues
[202]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-1/igt@[email protected]
[203]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-6/igt@[email protected]

* igt@prime_vgem@basic-fence-read:
- {shard-rkl}: [SKIP][204] ([fdo#109295] / [i915#3291] / [i915#3708]) -> [PASS][205]
[204]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-rkl-2/igt@[email protected]
[205]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-rkl-5/igt@[email protected]

#### Warnings ####

* igt@gem_exec_balancer@parallel-ordering:
- shard-iclb: [FAIL][206] ([i915#6117]) -> [SKIP][207] ([i915#4525])
[206]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb4/igt@[email protected]
[207]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb6/igt@[email protected]

* igt@kms_psr2_sf@cursor-plane-move-continuous-exceed-sf:
- shard-iclb: [SKIP][208] ([i915#2920]) -> [SKIP][209] ([i915#658]) +1 similar issue
[208]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb2/igt@[email protected]
[209]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb7/igt@[email protected]

* igt@kms_psr2_sf@cursor-plane-update-sf:
- shard-iclb: [SKIP][210] ([fdo#111068] / [i915#658]) -> [SKIP][211] ([i915#2920])
[210]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb1/igt@[email protected]
[211]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb2/igt@[email protected]

* igt@kms_psr2_su@page_flip-p010:
- shard-iclb: [SKIP][212] ([fdo#109642] / [fdo#111068] / [i915#658]) -> [FAIL][213] ([i915#5939])
[212]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-iclb7/igt@kms_psr2_su@page_flip-p010.html
[213]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-iclb2/igt@kms_psr2_su@page_flip-p010.html

* igt@runner@aborted:
- shard-apl: ([FAIL][214], [FAIL][215], [FAIL][216], [FAIL][217], [FAIL][218], [FAIL][219]) ([i915#180] / [i915#3002] / [i915#4312]) -> ([FAIL][220], [FAIL][221], [FAIL][222], [FAIL][223], [FAIL][224], [FAIL][225], [FAIL][226], [FAIL][227], [FAIL][228]) ([fdo#109271] / [i915#180] / [i915#3002] / [i915#4312])
[214]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl1/igt@[email protected]
[215]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl6/igt@[email protected]
[216]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl8/igt@[email protected]
[217]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl2/igt@[email protected]
[218]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl1/igt@[email protected]
[219]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_12197/shard-apl1/igt@[email protected]
[220]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl8/igt@[email protected]
[221]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl6/igt@[email protected]
[222]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@[email protected]
[223]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl1/igt@[email protected]
[224]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl1/igt@[email protected]
[225]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl2/igt@[email protected]
[226]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl6/igt@[email protected]
[227]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl6/igt@[email protected]
[228]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_100428v7/shard-apl6/igt@[email protected]

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

[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[fdo#109279]: https://bugs.freedesktop.org/show_bug.cgi?id=109279
[fdo#109289]: https://bugs.freedesktop.org/show_bug.cgi?id=109289
[fdo#109295]: https://bugs.freedesktop.org/show_bug.cgi?id=109295
[fdo#109313]: https://bugs.freedesktop.org/show_bug.cgi?id=109313
[fdo#109441]: https://bugs.freedesktop.org/show_bug.cgi?id=109441
[fdo#109642]: https://bugs.freedesktop.org/show_bug.cgi?id=109642
[fdo#110254]: https://bugs.freedesktop.org/show_bug.cgi?id=110254
[fdo#110723]: https://bugs.freedesktop.org/show_bug.cgi?id=110723
[fdo#111068]: https://bugs.freedesktop.org/show_bug.cgi?id=111068
[fdo#111614]: https://bugs.freedesktop.org/show_bug.cgi?id=111614
[fdo#111615]: https://bugs.freedesktop.org/show_bug.cgi?id=111615
[fdo#111825]: https://bugs.freedesktop.org/show_bug.cgi?id=111825
[fdo#111827]: https://bugs.freedesktop.org/show_bug.cgi?id=111827
[i915#1072]: https://gitlab.freedesktop.org/drm/intel/issues/1072
[i915#1257]: https://gitlab.freedesktop.org/drm/intel/issues/1257
[i915#132]: https://gitlab.freedesktop.org/drm/intel/issues/132
[i915#1769]: https://gitlab.freedesktop.org/drm/intel/issues/1769
[i915#180]: https://gitlab.freedesktop.org/drm/intel/issues/180
[i915#1825]: https://gitlab.freedesktop.org/drm/intel/issues/1825
[i915#1845]: https://gitlab.freedesktop.org/drm/intel/issues/1845
[i915#1849]: https://gitlab.freedesktop.org/drm/intel/issues/1849
[i915#1911]: https://gitlab.freedesktop.org/drm/intel/issues/1911
[i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
[i915#2105]: https://gitlab.freedesktop.org/drm/intel/issues/2105
[i915#2436]: https://gitlab.freedesktop.org/drm/intel/issues/2436
[i915#2437]: https://gitlab.freedesktop.org/drm/intel/issues/2437
[i915#2527]: https://gitlab.freedesktop.org/drm/intel/issues/2527
[i915#2532]: https://gitlab.freedesktop.org/drm/intel/issues/2532
[i915#2582]: https://gitlab.freedesktop.org/drm/intel/issues/2582
[i915#2587]: https://gitlab.freedesktop.org/drm/intel/issues/2587
[i915#2658]: https://gitlab.freedesktop.org/drm/intel/issues/2658
[i915#2672]: https://gitlab.freedesktop.org/drm/intel/issues/2672
[i915#2681]: https://gitlab.freedesktop.org/drm/intel/issues/2681
[i915#2842]: https://gitlab.freedesktop.org/drm/intel/issues/2842
[i915#2920]: https://gitlab.freedesktop.org/drm/intel/issues/2920
[i915#3002]: https://gitlab.freedesktop.org/drm/intel/issues/3002
[i915#3281]: https://gitlab.freedesktop.org/drm/intel/issues/3281
[i915#3282]: https://gitlab.freedesktop.org/drm/intel/issues/3282
[i915#3291]: https://gitlab.freedesktop.org/drm/intel/issues/3291
[i915#3359]: https://gitlab.freedesktop.org/drm/intel/issues/3359
[i915#3361]: https://gitlab.freedesktop.org/drm/intel/issues/3361
[i915#3546]: https://gitlab.freedesktop.org/drm/intel/issues/3546
[i915#3555]: https://gitlab.freedesktop.org/drm/intel/issues/3555
[i915#3558]: https://gitlab.freedesktop.org/drm/intel/issues/3558
[i915#3591]: https://gitlab.freedesktop.org/drm/intel/issues/3591
[i915#3637]: https://gitlab.freedesktop.org/drm/intel/issues/3637
[i915#3638]: https://gitlab.freedesktop.org/drm/intel/issues/3638
[i915#3692]: https://gitlab.freedesktop.org/drm/intel/issues/3692
[i915#3708]: https://gitlab.freedesktop.org/drm/intel/issues/3708
[i915#3734]: https://gitlab.freedesktop.org/drm/intel/issues/3734
[i915#3886]: https://gitlab.freedesktop.org/drm/intel/issues/3886
[i915#4070]: https://gitlab.freedesktop.org/drm/intel/issues/4070
[i915#4078]: https://gitlab.freedesktop.org/drm/intel/issues/4078
[i915#4098]: https://gitlab.freedesktop.org/drm/intel/issues/4098
[i915#4312]: https://gitlab.freedesktop.org/drm/intel/issues/4312
[i915#4338]: https://gitlab.freedesktop.org/drm/intel/issues/4338
[i915#4349]: https://gitlab.freedesktop.org/drm/intel/issues/4349
[i915#4392]: https://gitlab.freedesktop.org/drm/intel/issues/4392
[i915#4525]: https://gitlab.freedesktop.org/drm/intel/issues/4525
[i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
[i915#4767]: https://gitlab.freedesktop.org/drm/intel/issues/4767
[i915#4883]: https://gitlab.freedesktop.org/drm/intel/issues/4883
[i915#4939]: https://gitlab.freedesktop.org/drm/intel/issues/4939
[i915#4998]: https://gitlab.freedesktop.org/drm/intel/issues/4998
[i915#5099]: https://gitlab.freedesktop.org/drm/intel/issues/5099
[i915#5176]: https://gitlab.freedesktop.org/drm/intel/issues/5176
[i915#5235]: https://gitlab.freedesktop.org/drm/intel/issues/5235
[i915#5286]: https://gitlab.freedesktop.org/drm/intel/issues/5286
[i915#5289]: https://gitlab.freedesktop.org/drm/intel/issues/5289
[i915#5325]: https://gitlab.freedesktop.org/drm/intel/issues/5325
[i915#5327]: https://gitlab.freedesktop.org/drm/intel/issues/5327
[i915#533]: https://gitlab.freedesktop.org/drm/intel/issues/533
[i915#5566]: https://gitlab.freedesktop.org/drm/intel/issues/5566
[i915#5591]: https://gitlab.freedesktop.org/drm/intel/issues/5591
[i915#5939]: https://gitlab.freedesktop.org/drm/intel/issues/5939
[i915#6095]: https://gitlab.freedesktop.org/drm/intel/issues/6095
[i915#6117]: https://gitlab.freedesktop.org/drm/intel/issues/6117
[i915#6247]: https://gitlab.freedesktop.org/drm/intel/issues/6247
[i915#6248]: https://gitlab.freedesktop.org/drm/intel/issues/6248
[i915#6252]: https://gitlab.freedesktop.org/drm/intel/issues/6252
[i915#6258]: https://gitlab.freedesktop.org/drm/intel/issues/6258
[i915#6268]: https://gitlab.freedesktop.org/drm/intel/issues/6268
[i915#6458]: https://gitlab.freedesktop.org/drm/intel/issues/6458
[i915#6497]: https://gitlab.freedesktop.org/drm/intel/issues/6497
[i915#658]: https://gitlab.freedesktop.org/drm/intel/issues/658
[i915#6778]: https://gitlab.freedesktop.org/drm/intel/issues/6778
[i915#6973]: https://gitlab.freedesktop.org/drm/intel/issues/6973
[i915#716]: https://gitlab.freedesktop.org/drm/intel/issues/716
[i915#79]: https://gitlab.freedesktop.org/drm/intel/issues/79

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

* Linux: CI_DRM_12197 -> Patchwork_100428v7

CI-20190529: 20190529
CI_DRM_12197: cafa326de8e7860d45639e61bf66ec9c218207b1 @ git://anongit.freedesktop.org/gfx-ci/linux
IGT_6668: 5f29c9369550164b35b65baaaeba4b370f434cf1 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
Patchwork_100428v7: cafa326de8e7860d45639e61bf66ec9c218207b1 @ git://anongit.freedesktop.org/gfx-ci/linux
piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit

== Logs ==

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