Skip to contentSkip to conversation

Update IGT tests to support new engine busyness interface

PATCH In review Umesh Nerlige Ramappa 2 participants 9 messages Sep 22, 2023 – Sep 23, 2023

lore
Share & tools
lore
#0 lore raw

cover Update IGT tests to support new engine busyness interface

MTL introduces a new mechanism to query engine busyness from GuC that is less error prone and does not need the KMD to extend counters to 64 bits. This means KMD can get rid of the worker that regularly updates counters to 64 bits and is a simpler implementation.

GuC provides 2 counters to calculate busyness:

(1) xxxx-busy-ticks that provides engine busyness in ticks
(2) total-active-ticks[-gtN] that provides how long the gt has been active

The 2 values enable user to calculate the busyness % as follows:

busyness % = (delta xxxx-busy-ticks * 100) / (delta total-active-ticks)

Update IGT tests to use this new interface.

While this simplifies the implemantation and reduces a bunch of races that existed with current upstream version, the granularity for the active busyness of an engine is now 100 ms. Any higher granularity will add overhead to GuC since GuC is periodically updating this busyness.

Umesh Nerlige Ramappa (5):
i915/pmu: Add helpers to convert ticks to ns
i915/pmu: Pass config directly to the init test i915/pmu: Switch to new busyness counter if old one is unavailable lib/i915: Export engine to gt mapping
i915/pmu: Add a new test to use total_active_ticks for busyness

 lib/i915/gem_engine_topology.c |   2 +-
 lib/i915/gem_engine_topology.h |   1 +
 lib/i915/i915_drm_local.h      |  10 ++
 tests/intel/perf_pmu.c         | 276 +++++++++++++++++++++++++++------
 4 files changed, 241 insertions(+), 48 deletions(-)
Signature · 1 line
2.38.1
#1 lore raw

PATCH 1/5 i915/pmu: Add helpers to convert ticks to ns

MTL is introducing a 2 new counters to read busyness in ticks rather than nanoseconds:

(1) A counter that returns engine busyness in ticks (xxxx-busy-ticks)
(2) A counter that returns gt active time in ticks (total-active-ticks)

Busyness % = (delta-xxxx-busy-ticks * 100) / delta-total-active-ticks

At the same time it is deprecating the old busyness counter that would require the kernel to convert the ticks to ns.

Current IGT modifications are not using total-active-ticks since that is a larger change and more thought needs to go into incorporating that into the tests. That will be part of a follow up series. For now, add some helpers to the IGT tests to convert the ticks to ns.

---
 tests/intel/perf_pmu.c | 69 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
tests/intel/perf_pmu.c +69 -0
index c6e6a8b77..87078ad38 100644
@@ -255,6 +255,72 @@ IGT_TEST_DESCRIPTION("Test the i915 pmu perf interface");
 
 const double tolerance = 0.05f;
 const unsigned long batch_duration_ns = 500e6;
+static bool busy_ticks_only;
+static uint32_t cs_ts_freq;
+
+static bool strendswith(const char *str, const char *endswith)
+{
+	unsigned int endlen = strlen(endswith);
+	unsigned int str_len = strlen(str);
+
+	if (str_len < endlen)
+		return false;
+
+	return strcmp(str + (str_len - endlen), endswith) == 0;
+}
+
+static bool pmu_supports_event(int i915, const char *event_end)
+{
+	struct dirent *dent;
+	bool found = false;
+	int pmu_fd;
+	DIR *d;
+
+	pmu_fd = igt_perf_events_dir(i915);
+	igt_require(pmu_fd >= 0);
+
+	d = fdopendir(dup(pmu_fd));
+	igt_assert(d);
+	rewinddir(d);
+
+	while ((dent = readdir(d)) != NULL) {
+		if (dent->d_type != DT_REG)
+			continue;
+
+		if (strendswith(dent->d_name, event_end)) {
+			found = true;
+			break;
+		}
+	}
+
+	closedir(d);
+	close(pmu_fd);
+
+	return found;
+}
+
+static bool pmu_supports_only_busy_ticks(int i915)
+{
+	return pmu_supports_event(i915, "-busy-ticks") &&
+	       !pmu_supports_event(i915, "-busy");
+}
+
+static uint32_t
+cs_timestamp_frequency(int fd)
+{
+	struct drm_i915_getparam gp = {};
+	static uint32_t value;
+
+	if (value)
+		return value;
+
+	gp.param = I915_PARAM_CS_TIMESTAMP_FREQUENCY;
+	gp.value = (int *)(&value);
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_I915_GETPARAM, &gp), 0);
+
+	return value;
+}
 
 char *drpc;
 const char *no_debug_data = "\0";
@@ -2482,6 +2548,9 @@ igt_main
 
 		i915_for_each_gt(fd, tmp, gt)
 			num_gt++;
+
+		busy_ticks_only = pmu_supports_only_busy_ticks(fd);
+		cs_ts_freq = cs_timestamp_frequency(fd);
 	}
 
 	igt_describe("Verify i915 pmu dir exists and read all events");
Signature · 1 line
2.38.1
#2 lore raw

PATCH 2/5 i915/pmu: Pass config directly to the init test

In reply to Umesh Nerlige Ramappa

The busy config may need to be modified across the tests for a new busyness interface. In preparation for that, pass the config directly to the init test.

---
 tests/intel/perf_pmu.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)
tests/intel/perf_pmu.c +8 -9
index 87078ad38..eafa3d988 100644
@@ -356,22 +356,21 @@ static int open_group(int i915, uint64_t config, int group)
 	return fd;
 }
 
-static void
-init(int gem_fd, const intel_ctx_t *ctx,
-     const struct intel_execution_engine2 *e, uint8_t sample)
+static void init(int gem_fd, const intel_ctx_t *ctx,
+		 const struct intel_execution_engine2 *e, uint64_t config)
 {
 	int fd, err = 0;
 	bool exists;
 
 	errno = 0;
-	fd = perf_i915_open(gem_fd,
-			    __I915_PMU_ENGINE(e->class, e->instance, sample));
+	fd = perf_i915_open(gem_fd, config);
+
 	if (fd < 0)
 		err = errno;
 
 	exists = gem_context_has_engine(gem_fd, ctx->id, e->flags);
 	if (intel_gen(intel_get_drm_devid(gem_fd)) < 6 &&
-	    sample == I915_SAMPLE_SEMA)
+	    config == I915_PMU_ENGINE_SEMA(e->class, e->instance))
 		exists = false;
 
 	if (exists) {
@@ -2581,13 +2580,13 @@ igt_main
 	 * is correctly rejected.
 	 */
 	test_each_engine("init-busy", fd, ctx, e)
-		init(fd, ctx, e, I915_SAMPLE_BUSY);
+		init(fd, ctx, e, I915_PMU_ENGINE_BUSY(e->class, e->instance));
 
 	test_each_engine("init-wait", fd, ctx, e)
-		init(fd, ctx, e, I915_SAMPLE_WAIT);
+		init(fd, ctx, e, I915_PMU_ENGINE_WAIT(e->class, e->instance));
 
 	test_each_engine("init-sema", fd, ctx, e)
-		init(fd, ctx, e, I915_SAMPLE_SEMA);
+		init(fd, ctx, e, I915_PMU_ENGINE_SEMA(e->class, e->instance));
 
 	/**
 	 * Test that engines show no load when idle.
Signature · 1 line
2.38.1
#3 lore raw

PATCH 3/5 i915/pmu: Switch to new busyness counter if old one is unavailable

In reply to Umesh Nerlige Ramappa

MTL onwards, the old busyness counter is deprecated and users must use the busyness ticks counter. Add support in IGT tests to switch to new counter as needed.

---
 lib/i915/i915_drm_local.h |  10 ++++
 tests/intel/perf_pmu.c    | 115 +++++++++++++++++++++++++-------------
 2 files changed, 86 insertions(+), 39 deletions(-)
lib/i915/i915_drm_local.h +10 -0
index 0f47578c6..b94b88de3 100644
@@ -26,6 +26,13 @@ extern "C" {
 #define DRM_I915_PERF_PROP_OA_ENGINE_CLASS	9
 #define DRM_I915_PERF_PROP_OA_ENGINE_INSTANCE	10
 
+#define I915_SAMPLE_BUSY_TICKS (I915_SAMPLE_SEMA + 1)
+
+#define I915_PMU_ENGINE_BUSY_TICKS(class, instance) \
+	__I915_PMU_ENGINE(class, instance, I915_SAMPLE_BUSY_TICKS)
+
+#define I915_PMU_TOTAL_ACTIVE_TICKS	__I915_PMU_OTHER(5)
+
 /*
  * Top 4 bits of every non-engine counter are GT id.
  */
@@ -40,6 +47,9 @@ extern "C" {
 #define __I915_PMU_INTERRUPTS(gt)		___I915_PMU_OTHER(gt, 2)
 #define __I915_PMU_RC6_RESIDENCY(gt)		___I915_PMU_OTHER(gt, 3)
 #define __I915_PMU_SOFTWARE_GT_AWAKE_TIME(gt)	___I915_PMU_OTHER(gt, 4)
+#define __I915_PMU_TOTAL_ACTIVE_TICKS(gt)	___I915_PMU_OTHER(gt, 5)
+
+#define   I915_SCHEDULER_CAP_ENGINE_BUSY_TICKS_STATS	(1ul << 5)
 
 #define I915_GEM_CREATE_EXT_SET_PAT 2
 
tests/intel/perf_pmu.c +76 -39

343 lines not on this page · raw message

Signature · 1 line
2.38.1
#4 lore raw

PATCH 4/5 lib/i915: Export engine to gt mapping

In reply to Umesh Nerlige Ramappa

Some tests benefit from this helper. Export it.

---
 lib/i915/gem_engine_topology.c | 2 +-
 lib/i915/gem_engine_topology.h | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
lib/i915/gem_engine_topology.c +1 -1
index 7c6cd9ba9..a823e47a1 100644
@@ -370,7 +370,7 @@ mtl_engine_to_gt_map(const struct i915_engine_class_instance *e)
 	}
 }
 
-static int gem_engine_to_gt_map(int i915, const struct i915_engine_class_instance *engine)
+int gem_engine_to_gt_map(int i915, const struct i915_engine_class_instance *engine)
 {
 	uint32_t devid = intel_get_drm_devid(i915);
 
lib/i915/gem_engine_topology.h +1 -0
index 89642c317..8964ce5f7 100644
@@ -61,6 +61,7 @@ intel_get_current_physical_engine(struct intel_engine_data *ed);
 
 void intel_next_engine(struct intel_engine_data *ed);
 
+int gem_engine_to_gt_map(int i915, const struct i915_engine_class_instance *engine);
 struct i915_engine_class_instance *
 gem_list_engines(int i915,
 		 uint32_t gt_mask,
Signature · 1 line
2.38.1
#5 lore raw

PATCH 5/5 i915/pmu: Add a new test to use total_active_ticks for busyness

In reply to Umesh Nerlige Ramappa

Busyness percentage can be calculated using the total-active-ticks counter as follows:

% busyness = ((delta of xxxx-busy-ticks) * 100) / delta total-active-ticks

Add a test to check busyness using this method.

Note that total-active-ticks is updated only every 100 ms, so granularity of the busy-idle test is affected. To account for this, the test duration is set to a larger value for the new busyness interface.

---
 tests/intel/perf_pmu.c | 77 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
tests/intel/perf_pmu.c +77 -0
index 5999d1e22..80182dbfa 100644
@@ -249,6 +249,16 @@
  * Description: Test the i915 pmu perf interface
  * Feature: i915 pmu perf interface, pmu
  * Test category: Perf
+ *
+ * SUBTEST: busy-ticks
+ * Description: Test the i915 v2 engine active busyness interface
+ * Feature: i915 pmu perf interface, pmu
+ * Test category: Perf
+ *
+ * SUBTEST: busy-idle-ticks
+ * Description: Test the i915 v2 engine idle busyness interface
+ * Feature: i915 pmu perf interface, pmu
+ * Test category: Perf
  */
 
 IGT_TEST_DESCRIPTION("Test the i915 pmu perf interface");
@@ -2547,6 +2557,63 @@ static void pmu_read(int i915)
 	close(pmu_fd);
 }
 
+static void
+single_ticks(int gem_fd, const intel_ctx_t *ctx,
+	     const struct intel_execution_engine2 *e, unsigned int flags)
+{
+	igt_spin_t *spin;
+	uint64_t before[2], after[2];
+	uint64_t busy_ticks, total_active_ticks;
+	int fd[2];
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	struct i915_engine_class_instance ci = {
+		e->class,
+		e->instance,
+	};
+	int gt = gem_engine_to_gt_map(gem_fd, &ci);
+	double busy_percent;
+	const unsigned long batch_long_duration_ns = 2000e6;
+
+	fd[0] = open_group(gem_fd, __I915_PMU_ENGINE_BUSY(e->class, e->instance), -1);
+	fd[1] = open_group(gem_fd, __I915_PMU_TOTAL_ACTIVE_TICKS(gt), fd[0]);
+
+	if (flags & TEST_BUSY) {
+		spin = igt_sync_spin(gem_fd, ahnd, ctx, e);
+	} else {
+		spin = NULL;
+		gem_quiescent_gpu(gem_fd);
+	}
+
+	pmu_read_multi(fd[0], 2, before);
+	measured_usleep(batch_long_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	pmu_read_multi(fd[0], 2, after);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+
+	busy_ticks = after[0] - before[0];
+	total_active_ticks = after[1] - before[1];
+
+	igt_info("BUSY: after %ld, before %ld\n", after[0], before[0]);
+	igt_info("TOTAL: after %ld, before %ld\n", after[1], before[1]);
+	igt_info("BUSY: delta %ld\n", busy_ticks);
+	igt_info("TOTAL: delta %ld\n", total_active_ticks);
+
+	busy_percent = (double)(busy_ticks * 100) / (double)total_active_ticks;
+
+	igt_info("LOCAL: percent %f\n", busy_percent);
+
+	igt_assert(busy_percent >= 95);
+
+	igt_spin_free(gem_fd, spin);
+	close(fd[0]);
+	close(fd[1]);
+	put_ahnd(ahnd);
+
+	gem_quiescent_gpu(gem_fd);
+}
+
 #define test_each_engine(T, i915, ctx, e) \
 	igt_subtest_with_dynamic(T) for_each_ctx_engine(i915, ctx, e) \
 		igt_dynamic_f("%s", e->name)
@@ -2639,6 +2706,16 @@ igt_main
 	test_each_engine("busy-idle", fd, ctx, e)
 		single(fd, ctx, e, TEST_BUSY | TEST_TRAILING_IDLE);
 
+	igt_subtest_group {
+		igt_fixture igt_require(busy_ticks_only);
+
+		test_each_engine("busy-ticks", fd, ctx, e)
+			single_ticks(fd, ctx, e, TEST_BUSY);
+
+		test_each_engine("busy-idle-ticks", fd, ctx, e)
+			single_ticks(fd, ctx, e, TEST_BUSY | TEST_TRAILING_IDLE);
+	}
+
 	/**
 	 * Test that when one engine is loaded other report no
 	 * load.
Signature · 1 line
2.38.1
#6 lore raw

Re: [igt-dev] [PATCH i-g-t 5/5] i915/pmu: Add a new test to use total_active_ticks for busyness

Quoted 77 lines · Umesh Nerlige Ramappa

Busyness percentage can be calculated using the total-active-ticks counter as follows:

% busyness = ((delta of xxxx-busy-ticks) * 100) / delta total-active-ticks

Add a test to check busyness using this method.

Note that total-active-ticks is updated only every 100 ms, so granularity of the busy-idle test is affected. To account for this, the test duration is set to a larger value for the new busyness interface.

---
tests/intel/perf_pmu.c | 77 ++++++++++++++++++++++++++++++++++++++++++

1 file changed, 77 insertions(+)
tests/intel/perf_pmu.c +46 -0
index 5999d1e22..80182dbfa 100644
@@ -249,6 +249,16 @@
 * Description: Test the i915 pmu perf interface
 * Feature: i915 pmu perf interface, pmu
 * Test category: Perf
+ *
+ * SUBTEST: busy-ticks
+ * Description: Test the i915 v2 engine active busyness interface
+ * Feature: i915 pmu perf interface, pmu
+ * Test category: Perf
+ *
+ * SUBTEST: busy-idle-ticks
+ * Description: Test the i915 v2 engine idle busyness interface
+ * Feature: i915 pmu perf interface, pmu
+ * Test category: Perf
 */
 
 IGT_TEST_DESCRIPTION("Test the i915 pmu perf interface");
@@ -2547,6 +2557,63 @@ static void pmu_read(int i915)
 	close(pmu_fd);
 }
 
+static void
+single_ticks(int gem_fd, const intel_ctx_t *ctx,
+	     const struct intel_execution_engine2 *e, unsigned int flags)
+{
+	igt_spin_t *spin;
+	uint64_t before[2], after[2];
+	uint64_t busy_ticks, total_active_ticks;
+	int fd[2];
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	struct i915_engine_class_instance ci = {
+		e->class,
+		e->instance,
+	};
+	int gt = gem_engine_to_gt_map(gem_fd, &ci);
+	double busy_percent;
+	const unsigned long batch_long_duration_ns = 2000e6;
+
+	fd[0] = open_group(gem_fd, __I915_PMU_ENGINE_BUSY(e->class, e->instance), -1);
+	fd[1] = open_group(gem_fd, __I915_PMU_TOTAL_ACTIVE_TICKS(gt), fd[0]);
+
+	if (flags & TEST_BUSY) {
+		spin = igt_sync_spin(gem_fd, ahnd, ctx, e);
+	} else {
+		spin = NULL;
+		gem_quiescent_gpu(gem_fd);
+	}
+
+	pmu_read_multi(fd[0], 2, before);
+	measured_usleep(batch_long_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	pmu_read_multi(fd[0], 2, after);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+
+	busy_ticks = after[0] - before[0];

tests/intel/perf_pmu.c static void pmu_read(int i915) · line 2605

Quoted 10 lines
tests/intel/perf_pmu.c +10 -0
+	total_active_ticks = after[1] - before[1];
+
+	igt_info("BUSY: after %ld, before %ld\n", after[0], before[0]);
+	igt_info("TOTAL: after %ld, before %ld\n", after[1], before[1]);
+	igt_info("BUSY: delta %ld\n", busy_ticks);
+	igt_info("TOTAL: delta %ld\n", total_active_ticks);
+
+	busy_percent = (double)(busy_ticks * 100) / (double)total_active_ticks;
+
+	igt_info("LOCAL: percent %f\n", busy_percent);

Will drop the igt_info in the final revision since it is for debug

Umesh

#7 lore raw

[igt-dev] ✗ Fi.CI.BAT: failure for Update IGT tests to support new engine busyness interface

In reply to Umesh Nerlige Ramappa
== Series Details ==

== Series Details ==

Series: Update IGT tests to support new engine busyness interface
URL : https://patchwork.freedesktop.org/series/124147/
State : failure

== Summary ==

CI Bug Log - changes from IGT_7499 -> IGTPW_9858
====================================================

Summary
-------

**FAILURE**

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

If you think the reported changes have nothing to do with the changes introduced in IGTPW_9858, please notify your bug team ([email protected]) to allow them to document this new failure mode, which will reduce false positives in CI.

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

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

Additional (1): fi-kbl-soraka
Missing (1): fi-snb-2520m

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

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

### IGT changes ###

#### Possible regressions ####

* igt@kms_pipe_crc_basic@suspend-read-crc@pipe-b-hdmi-a-3:
- bat-dg2-11: [PASS][1] -> [INCOMPLETE][2]
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7499/bat-dg2-11/igt@kms_pipe_crc_basic@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/bat-dg2-11/igt@kms_pipe_crc_basic@[email protected]

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

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

### IGT changes ###

#### Issues hit ####

* igt@gem_exec_suspend@basic-s0@smem:
- bat-dg2-9: [PASS][3] -> [INCOMPLETE][4] ([i915#9275])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7499/bat-dg2-9/igt@gem_exec_suspend@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/bat-dg2-9/igt@gem_exec_suspend@[email protected]

* igt@gem_huc_copy@huc-copy:
- fi-kbl-soraka: NOTRUN -> [SKIP][5] ([fdo#109271] / [i915#2190])
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/fi-kbl-soraka/igt@[email protected]

* igt@gem_lmem_swapping@basic:
- fi-kbl-soraka: NOTRUN -> [SKIP][6] ([fdo#109271] / [i915#4613]) +3 other tests skip
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/fi-kbl-soraka/igt@[email protected]

* igt@i915_selftest@live@gt_pm:
- fi-kbl-soraka: NOTRUN -> [DMESG-FAIL][7] ([i915#1886] / [i915#7913])
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/fi-kbl-soraka/igt@i915_selftest@live@gt_pm.html

* igt@i915_selftest@live@requests:
- bat-mtlp-6: [PASS][8] -> [ABORT][9] ([i915#9262])
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7499/bat-mtlp-6/igt@i915_selftest@[email protected]
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/bat-mtlp-6/igt@i915_selftest@[email protected]

* igt@i915_suspend@basic-s2idle-without-i915:
- fi-apl-guc: [PASS][10] -> [INCOMPLETE][11] ([i915#1982] / [i915#4528])
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7499/fi-apl-guc/igt@[email protected]
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/fi-apl-guc/igt@[email protected]

* igt@kms_dsc@dsc-basic:
- fi-kbl-soraka: NOTRUN -> [SKIP][12] ([fdo#109271]) +9 other tests skip
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/fi-kbl-soraka/igt@[email protected]

* igt@kms_pipe_crc_basic@nonblocking-crc-frame-sequence:
- bat-dg2-11: NOTRUN -> [SKIP][13] ([i915#1845]) +3 other tests skip
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/bat-dg2-11/igt@[email protected]

#### Possible fixes ####

* igt@kms_hdmi_inject@inject-audio:
- fi-kbl-guc: [FAIL][14] ([IGT#3]) -> [PASS][15]
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7499/fi-kbl-guc/igt@[email protected]
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/fi-kbl-guc/igt@[email protected]

[IGT#3]: https://gitlab.freedesktop.org/drm/igt-gpu-tools/issues/3
[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[i915#1845]: https://gitlab.freedesktop.org/drm/intel/issues/1845
[i915#1886]: https://gitlab.freedesktop.org/drm/intel/issues/1886
[i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
[i915#2190]: https://gitlab.freedesktop.org/drm/intel/issues/2190
[i915#4528]: https://gitlab.freedesktop.org/drm/intel/issues/4528
[i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
[i915#7913]: https://gitlab.freedesktop.org/drm/intel/issues/7913
[i915#9262]: https://gitlab.freedesktop.org/drm/intel/issues/9262
[i915#9275]: https://gitlab.freedesktop.org/drm/intel/issues/9275

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

* CI: CI-20190529 -> None
* IGT: IGT_7499 -> IGTPW_9858

CI-20190529: 20190529
CI_DRM_13671: e1973de2c4516e9130157e538014e79c8aa57b41 @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_9858: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/index.html
IGT_7499: d991240f6c6751e9480456c20de785cfc6e6ff15 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

Testlist changes
----------------

+igt@perf_pmu@busy-idle-ticks
+igt@perf_pmu@busy-ticks

== Logs ==

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

#8 lore raw

[igt-dev] ✓ CI.xeBAT: success for Update IGT tests to support new engine busyness interface

In reply to Umesh Nerlige Ramappa
== Series Details ==

== Series Details ==

Series: Update IGT tests to support new engine busyness interface
URL : https://patchwork.freedesktop.org/series/124147/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_7499_BAT -> XEIGTPW_9858_BAT
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (4 -> 4)
------------------------------

No changes in participating hosts

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

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

### IGT changes ###

#### Possible fixes ####

* {igt@xe_create@create-execqueues-noleak}:
- bat-atsm-2: [FAIL][1] ([Intel XE#524]) -> [PASS][2]
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7499/bat-atsm-2/igt@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_9858/bat-atsm-2/igt@[email protected]

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

[Intel XE#524]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/524

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

* IGT: IGT_7499 -> IGTPW_9858
* Linux: xe-390-6149acb947f2f8b65ee1a058982a5d6fce3124ec -> xe-392-16e2c940ef53f81b2c68e16ec39cf5772894a625

IGTPW_9858: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_9858/index.html
IGT_7499: d991240f6c6751e9480456c20de785cfc6e6ff15 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
xe-390-6149acb947f2f8b65ee1a058982a5d6fce3124ec: 6149acb947f2f8b65ee1a058982a5d6fce3124ec xe-392-16e2c940ef53f81b2c68e16ec39cf5772894a625: 16e2c940ef53f81b2c68e16ec39cf5772894a625

== Logs ==

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