[Intel-gfx] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Intel-gfx] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

A set of subtests which exercises different paths to our shrinker code
(including the OOM killer) in predictable and reasonable time budget.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 lib/igt_core.c                        |  19 ++
 lib/igt_core.h                        |   1 +
 tests/i915/gem_shrink.c               | 399 ++++++++++++++++++++++++++
 tests/intel-ci/blacklist.txt          |   1 +
 tests/intel-ci/fast-feedback.testlist |   3 +
 5 files changed, 423 insertions(+)

diff --git a/lib/igt_core.c b/lib/igt_core.c
index 50d6008f6c82..351da0b4e020 100644
--- a/lib/igt_core.c
+++ b/lib/igt_core.c
@@ -1685,6 +1685,25 @@ void igt_stop_helper(struct igt_helper_process *proc)
 	assert(helper_was_alive(proc, status));
 }
 
+/**
+ * igt_try_stop_helper:
+ * @proc: #igt_helper_process structure
+ *
+ * Terminates a helper process if it is still running and returns true, or false
+ * if the process wasn't running.
+ */
+bool igt_try_stop_helper(struct igt_helper_process *proc)
+{
+	int status;
+
+	/* failure here means the pid is already dead and so waiting is safe */
+	kill(proc->pid, proc->use_SIGKILL ? SIGKILL : SIGTERM);
+
+	status = igt_wait_helper(proc);
+
+	return helper_was_alive(proc, status);
+}
+
 static void children_exit_handler(int sig)
 {
 	int status;
diff --git a/lib/igt_core.h b/lib/igt_core.h
index 6f8c3852a686..ed5ceebf1205 100644
--- a/lib/igt_core.h
+++ b/lib/igt_core.h
@@ -795,6 +795,7 @@ bool __igt_fork_helper(struct igt_helper_process *proc);
 	for (; __igt_fork_helper(proc); exit(0))
 int igt_wait_helper(struct igt_helper_process *proc);
 void igt_stop_helper(struct igt_helper_process *proc);
+bool igt_try_stop_helper(struct igt_helper_process *proc);
 
 /* exit handler code */
 
diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
index c8e05814ee70..7c002de0ef1f 100644
--- a/tests/i915/gem_shrink.c
+++ b/tests/i915/gem_shrink.c
@@ -26,6 +26,10 @@
  *
  * Exercise the shrinker by overallocating GEM objects
  */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>
 
 #include "igt.h"
 #include "igt_gt.h"
@@ -366,6 +370,376 @@ static void reclaim(unsigned engine, int timeout)
 	close(fd);
 }
 
+static unsigned long get_meminfo(const char *info, const char *tag)
+{
+	const char *str;
+	unsigned long val;
+
+	str = strstr(info, tag);
+	if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
+		return val >> 10;
+
+	igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
+	return 0;
+}
+
+static unsigned long get_avail_ram_mb(void)
+{
+	int fd;
+	int ret;
+	char buf[4096];
+	unsigned long ram;
+
+	fd = open("/proc/meminfo", O_RDONLY);
+	igt_assert_fd(fd);
+
+	ret = read(fd, buf, sizeof(buf));
+	igt_assert(ret >= 0);
+
+	close(fd);
+
+	ram = get_meminfo(buf, "MemAvailable:");
+	ram += get_meminfo(buf, "Buffers:");
+	ram += get_meminfo(buf, "Cached:");
+	ram += get_meminfo(buf, "SwapCached:");
+
+	return ram;
+}
+
+struct test {
+#define TEST_BO		(1)
+#define TEST_USERPTR	(2)
+	unsigned int flags;
+	int fd;
+};
+
+static uint32_t __get_pages(int fd, unsigned long alloc)
+{
+	uint32_t handle = gem_create(fd, alloc);
+
+	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
+	gem_madvise(fd, handle, I915_MADV_DONTNEED);
+
+	return handle;
+}
+
+struct test_obj {
+	void *ptr;
+	uint32_t handle;
+};
+
+#define PAGE_SIZE 4096
+static void
+__get_userptr(int fd, struct test_obj *obj, unsigned long sz)
+{
+	struct local_i915_gem_userptr userptr = { };
+	void *ptr;
+
+	igt_assert_eq(sz & 4095, 0);
+
+	ptr = mmap(NULL, sz, PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	for (size_t page = 0; page < sz; page += PAGE_SIZE)
+		*(volatile uint32_t *)((unsigned char *)ptr + page) = 0;
+
+	userptr.user_size = sz;
+	userptr.user_ptr = to_user_pointer(ptr);
+	do_ioctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+
+	gem_set_domain(fd, userptr.handle, I915_GEM_DOMAIN_GTT, 0);
+	gem_madvise(fd, userptr.handle, I915_MADV_DONTNEED);
+
+	obj->ptr = ptr;
+	obj->handle = userptr.handle;
+}
+
+/*
+ * Use a specific way of using up memory until we are below a certain threshold.
+ */
+static void *mempressure(void *arg)
+{
+	const unsigned int free_threshold_mb = 256;
+	struct test_obj *list = NULL;
+	struct test *test = arg;
+	const unsigned int sz_mb = 2;
+	const unsigned int sz = sz_mb << 20;
+	unsigned int n = 0, max = 0;
+	unsigned int blocks;
+
+	for (;;) {
+		unsigned long ram_mb = get_avail_ram_mb();
+
+		if (!list) {
+			/*
+			 * On first pass estimate how many sz_mb sized blocks
+			 * we could need to use up all RAM.
+			 */
+			blocks = ram_mb / sz_mb;
+			list = calloc(blocks, sizeof(*list));
+			igt_assert(list);
+		} else if (ram_mb < free_threshold_mb) {
+			/* Limit the working set once under the threshold. */
+			blocks = max + 1;
+		}
+
+		/* Free the oldest block once the working set wrapped. */
+		if (list[n].ptr || list[n].handle) {
+			if (test->flags & TEST_USERPTR) {
+				munmap(list[n].ptr, sz);
+				gem_close(test->fd, list[n].handle);
+			} else if (test->flags & TEST_BO) {
+				gem_close(test->fd, list[n].handle);
+			} else {
+				munmap(list[n].ptr, sz);
+			}
+		}
+
+		/*
+		 * Allocate memory blocks and record the current working set
+		 * size.
+		 */
+		if (test->flags & TEST_BO) {
+			list[n].handle = __get_pages(test->fd, sz);
+		} else if (test->flags & TEST_USERPTR) {
+			__get_userptr(test->fd, &list[n], sz);
+		} else {
+			list[n].ptr = mmap(NULL, sz, PROT_WRITE,
+					   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+			assert(list[n].ptr != MAP_FAILED);
+
+			madvise(list[n].ptr, sz, MADV_HUGEPAGE);
+
+			for (size_t page = 0; page < sz; page += PAGE_SIZE)
+				*(volatile uint32_t *)((unsigned char *)list[n].ptr + page) = 0;
+		}
+
+		if (n > max)
+			max = n;
+
+		n++;
+
+		/*
+		 * Start freeing the oldest and reallocating once maximum
+		 * working set size has been reached.
+		 */
+		if (n >= blocks)
+			n = 0;
+	}
+
+	return NULL;
+}
+
+static void oom_adjust(const char *score)
+{
+	int fd;
+
+	fd = open("/proc/self/oom_score_adj", O_WRONLY);
+	igt_assert_fd(fd);
+	igt_assert(write(fd, score, sizeof(score)) == sizeof(score));
+	close(fd);
+}
+
+static void trigger_oom(void)
+{
+	const char *cmd = "f";
+	int fd;
+
+	fd = open("/proc/sysrq-trigger", O_WRONLY);
+	igt_assert_fd(fd);
+	igt_assert(write(fd, cmd, sizeof(cmd)) == sizeof(cmd));
+	close(fd);
+}
+
+static bool has_sysrq_trigger(void)
+{
+	int fd;
+
+	fd = open("/proc/sysrq-trigger", O_WRONLY);
+	close(fd);
+
+	return fd >= 0;
+}
+
+/*
+ * Exercise different paths to our shrinker code, including OOM, in predictable
+ * and reasonable time budget.
+ */
+static void reclaim_oom(unsigned int flags, unsigned int passes)
+{
+	unsigned int count = 0;
+
+	oom_adjust("-1000");
+
+	do {
+		struct igt_helper_process gem_child = { .use_SIGKILL = true };
+		struct igt_helper_process mem_child = { .use_SIGKILL = true };
+		struct igt_helper_process eb_child = { .use_SIGKILL = true };
+		struct igt_helper_process drop_child = { .use_SIGKILL = true };
+
+		igt_debug("Iteration %u...\n", ++count);
+
+		/*
+		 * Apply either anon backed or shmem backed memory pressure
+		 * to the amount to use up almost all available RAM.
+		 */
+		igt_fork_helper(&mem_child) {
+			struct test test = { };
+
+			if ((flags & (TEST_BO | TEST_USERPTR)) ==
+			    (TEST_BO | TEST_USERPTR))
+				test.flags = TEST_BO;
+
+			/* Sacrifice the memory hog if it comes to that. */
+			oom_adjust("500");
+
+			if (test.flags == TEST_BO) {
+				test.fd = drm_open_driver_render(DRIVER_INTEL);
+				igt_require_gem(test.fd);
+			}
+
+			mempressure(&test);
+
+			if (test.flags == TEST_BO)
+				close(test.fd);
+		}
+
+		/*
+		 * Apply either userptr backed or shmem backed memory pressure
+		 * to the amount to use up almost all available RAM.
+		 */
+		igt_fork_helper(&gem_child) {
+			struct test test = { .flags = flags };
+
+			if ((flags & (TEST_BO | TEST_USERPTR)) ==
+			    (TEST_BO | TEST_USERPTR))
+				test.flags = TEST_USERPTR;
+
+			/* Sacrifice the memory hog if it comes to that. */
+			oom_adjust("500");
+
+			test.fd = drm_open_driver_render(DRIVER_INTEL);
+			igt_require_gem(test.fd);
+
+			mempressure(&test);
+
+			close(test.fd);
+		}
+
+		/*
+		 * Apply an execbuf load to exercise the request allocation and
+		 * direct reclaim from this path.
+		 *
+		 * Occasionaly sync with execution and pause for a little bit to
+		 * avoid hogging to much from this client.
+		 */
+		igt_fork_helper(&eb_child) {
+			struct test test = { .flags = flags };
+			const uint32_t bbe = MI_BATCH_BUFFER_END;
+			struct drm_i915_gem_exec_object2 obj = { };
+			struct drm_i915_gem_execbuffer2 execbuf = { };
+
+			execbuf.buffers_ptr = to_user_pointer(&obj);
+			execbuf.buffer_count = 1;
+
+			test.fd = drm_open_driver_render(DRIVER_INTEL);
+			igt_require_gem(test.fd);
+
+			for (;;) {
+				unsigned long eb = 0;
+				struct timespec ts = { };
+				unsigned long start;
+
+				igt_nsec_elapsed(&ts);
+				start = igt_nsec_elapsed(&ts) / 1e6;
+
+				for (;;) {
+					unsigned long now;
+
+					obj.handle = gem_create(test.fd, 4096);
+					gem_write(test.fd, obj.handle, 0, &bbe,
+						sizeof(bbe));
+					gem_execbuf(test.fd, &execbuf);
+					eb++;
+					now = igt_nsec_elapsed(&ts) / 1e6;
+					if (now > (start + 1000)) {
+						gem_sync(test.fd, obj.handle);
+						if (now > (start + 2000)) {
+							gem_close(test.fd,
+								  obj.handle);
+							break;
+						}
+					}
+					gem_close(test.fd, obj.handle);
+				}
+
+				igt_debug("%lu execbufs\n", eb);
+				usleep(500e3);
+			}
+
+			close(test.fd);
+		}
+
+		/*
+		 * Manually drop cached with the DROP_ACTIVE flag set every now
+		 * and then in order to exercise this path as well.
+		 */
+		igt_fork_helper(&drop_child) {
+			int fd;
+
+			fd = drm_open_driver(DRIVER_INTEL);
+			igt_require_gem(fd);
+
+			for (;;) {
+				usleep(334e3);
+				igt_debug("Dropping caches...\n");
+				igt_drop_caches_set(fd, DROP_ACTIVE);
+			}
+
+			close(fd);
+		}
+
+		/*
+		 * When memory pressure clients have managed to use up all
+		 * available RAM, let them run for a brief moment yet and then
+		 * manually trigger the OOM condition.
+		 */
+		for (unsigned long ram_mb = 0;
+		     (ram_mb = get_avail_ram_mb()) > 512;) {
+			int status;
+			pid_t pid;
+
+			igt_debug("[%u] %lu MiB free\n", count, ram_mb);
+
+			pid = waitpid(mem_child.pid, &status, WNOHANG);
+			if (pid)
+				break;
+
+			pid = waitpid(gem_child.pid, &status, WNOHANG);
+			if (pid)
+				break;
+
+			pid = waitpid(eb_child.pid, &status, WNOHANG);
+			igt_assert_eq(pid, 0);
+
+			pid = waitpid(drop_child.pid, &status, WNOHANG);
+			igt_assert_eq(pid, 0);
+
+			sleep(1);
+		}
+
+		igt_debug("Triggering OOM...\n");
+		trigger_oom();
+
+		sleep(1);
+
+		igt_try_stop_helper(&mem_child);
+		igt_try_stop_helper(&gem_child);
+		igt_stop_helper(&eb_child);
+		igt_stop_helper(&drop_child);
+	} while (count < passes);
+}
+
 igt_main
 {
 	const struct test {
@@ -432,6 +806,31 @@ igt_main
 	igt_subtest("reclaim")
 		reclaim(I915_EXEC_DEFAULT, 2);
 
+	igt_subtest_group {
+		struct {
+			const char *name;
+			unsigned int flags;
+			unsigned int passes;
+		} *p, passes[] = {
+			{ "reclaims-and-oom-basic", TEST_BO, 1 },
+			{ "reclaims-and-oom", TEST_BO, 3 },
+			{ "reclaims-and-oom-userptr-basic", TEST_USERPTR, 1 },
+			{ "reclaims-and-oom-userptr", TEST_USERPTR, 3 },
+			{ "reclaims-and-oom-both-basic", TEST_BO | TEST_USERPTR, 1 },
+			{ "reclaims-and-oom-both", TEST_BO | TEST_USERPTR, 3 },
+			{ NULL, 0, 0 },
+		};
+
+		igt_fixture {
+			igt_require(has_sysrq_trigger());
+		}
+
+		for (p = passes; p->name; p++) {
+			igt_subtest(p->name)
+				reclaim_oom(p->flags, p->passes);
+		}
+	}
+
 	for(const struct test *t = tests; t->name; t++) {
 		for(const struct mode *m = modes; m->suffix; m++) {
 			igt_subtest_f("%s%s", t->name, m->suffix)
diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
index 73d127603d28..d76a4b3b1c71 100644
--- a/tests/intel-ci/blacklist.txt
+++ b/tests/intel-ci/blacklist.txt
@@ -60,6 +60,7 @@ igt@gem_ring_sync_copy(@.*)?
 igt@gem_ring_sync_loop(@.*)?
 igt@gem_seqno_wrap(@.*)?
 igt@gem_shrink@(?!reclaim$).*
+igt@gem_shrink@(?!reclaims-and-oom).*
 igt@gem_softpin@.*(hang|S4).*
 igt@gem_spin_batch(@.*)?
 igt@gem_stolen@.*hibernate.*
diff --git a/tests/intel-ci/fast-feedback.testlist b/tests/intel-ci/fast-feedback.testlist
index 6d42792c67f7..0df7cc2fd9fd 100644
--- a/tests/intel-ci/fast-feedback.testlist
+++ b/tests/intel-ci/fast-feedback.testlist
@@ -124,6 +124,9 @@ igt@gem_ringfill@basic-default
 igt@gem_ringfill@basic-default-interruptible
 igt@gem_ringfill@basic-default-forked
 igt@gem_ringfill@basic-default-fd
+igt@gem_shrink@reclaims-and-oom-basic
+igt@gem_shrink@reclaims-and-oom-userptr-basic
+igt@gem_shrink@reclaims-and-oom-both-basic
 igt@gem_sync@basic-all
 igt@gem_sync@basic-each
 igt@gem_sync@basic-many-each
-- 
2.19.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[igt-dev] ✓ Fi.CI.BAT: success for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Patchwork]

== Series Details ==

Series: tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time
URL   : https://patchwork.freedesktop.org/series/54746/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_5363 -> IGTPW_2185
====================================================

Summary
-------

  **WARNING**

  Minor unknown changes coming with IGTPW_2185 need to be verified
  manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_2185, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/54746/revisions/1/mbox/

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

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

### IGT changes ###

#### Warnings ####

  * igt@pm_rpm@basic-pci-d3-state:
    - fi-byt-j1900:       PASS -> SKIP
    - fi-bsw-kefka:       PASS -> SKIP

  
#### Suppressed ####

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

  * {igt@gem_shrink@reclaims-and-oom-userptr-basic}:
    - fi-bwr-2160:        NOTRUN -> FAIL +1
    - fi-kbl-7560u:       NOTRUN -> DMESG-WARN

  * {igt@runner@aborted}:
    - fi-kbl-7560u:       NOTRUN -> FAIL

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

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

### IGT changes ###

#### Issues hit ####

  * igt@pm_rpm@basic-rte:
    - fi-byt-j1900:       PASS -> FAIL [fdo#108800]
    - fi-bsw-kefka:       PASS -> FAIL [fdo#108800]

  
#### Possible fixes ####

  * igt@kms_chamelium@hdmi-hpd-fast:
    - fi-kbl-7500u:       FAIL [fdo#108767] -> PASS

  * igt@kms_frontbuffer_tracking@basic:
    - fi-hsw-peppy:       DMESG-WARN [fdo#102614] -> PASS

  * igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a-frame-sequence:
    - fi-byt-clapper:     FAIL [fdo#103191] / [fdo#107362] -> PASS +1

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

  [fdo#102614]: https://bugs.freedesktop.org/show_bug.cgi?id=102614
  [fdo#103191]: https://bugs.freedesktop.org/show_bug.cgi?id=103191
  [fdo#107362]: https://bugs.freedesktop.org/show_bug.cgi?id=107362
  [fdo#108767]: https://bugs.freedesktop.org/show_bug.cgi?id=108767
  [fdo#108800]: https://bugs.freedesktop.org/show_bug.cgi?id=108800


Participating hosts (47 -> 42)
------------------------------

  Additional (3): fi-byt-n2820 fi-apl-guc fi-pnv-d510 
  Missing    (8): fi-kbl-soraka fi-ilk-m540 fi-hsw-4200u fi-byt-squawks fi-bsw-cyan fi-ctg-p8600 fi-icl-y fi-blb-e6850 


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

    * IGT: IGT_4756 -> IGTPW_2185

  CI_DRM_5363: f141806c68e4cbd56e3a5a582eb1a6f5b7edfc84 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_2185: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2185/
  IGT_4756: 75081c6bfb9998bd7cbf35a7ac0578c683fe55a8 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools



== Testlist changes ==

+igt@gem_shrink@reclaims-and-oom
+igt@gem_shrink@reclaims-and-oom-basic
+igt@gem_shrink@reclaims-and-oom-both
+igt@gem_shrink@reclaims-and-oom-both-basic
+igt@gem_shrink@reclaims-and-oom-userptr
+igt@gem_shrink@reclaims-and-oom-userptr-basic

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2185/
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.IGT: success for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Patchwork]

== Series Details ==

Series: tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time
URL   : https://patchwork.freedesktop.org/series/54746/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_5363_full -> IGTPW_2185_full
====================================================

Summary
-------

  **WARNING**

  Minor unknown changes coming with IGTPW_2185_full need to be verified
  manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_2185_full, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/54746/revisions/1/mbox/

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

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

### IGT changes ###

#### Warnings ####

  * igt@pm_rc6_residency@rc6-accuracy:
    - shard-snb:          SKIP -> PASS

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

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

### IGT changes ###

#### Issues hit ####

  * igt@kms_busy@extended-modeset-hang-newfb-render-a:
    - shard-snb:          NOTRUN -> DMESG-WARN [fdo#107956]

  * igt@kms_busy@extended-modeset-hang-newfb-render-c:
    - shard-kbl:          PASS -> DMESG-WARN [fdo#107956]

  * igt@kms_cursor_crc@cursor-128x128-onscreen:
    - shard-kbl:          PASS -> FAIL [fdo#103232] +1

  * igt@kms_cursor_crc@cursor-256x256-random:
    - shard-glk:          PASS -> FAIL [fdo#103232] +2

  * igt@kms_cursor_crc@cursor-256x85-sliding:
    - shard-apl:          PASS -> FAIL [fdo#103232] +3

  * igt@kms_flip@flip-vs-expired-vblank:
    - shard-glk:          PASS -> FAIL [fdo#105363]

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-draw-pwrite:
    - shard-apl:          PASS -> FAIL [fdo#103167] +3

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-cpu:
    - shard-kbl:          PASS -> FAIL [fdo#103167]

  * igt@kms_frontbuffer_tracking@fbc-1p-rte:
    - shard-glk:          PASS -> FAIL [fdo#103167] / [fdo#105682]

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-onoff:
    - shard-glk:          PASS -> FAIL [fdo#103167] +4

  * igt@kms_plane@plane-position-covered-pipe-c-planes:
    - shard-apl:          PASS -> FAIL [fdo#103166] +3

  * igt@kms_plane_alpha_blend@pipe-c-alpha-opaque-fb:
    - shard-glk:          PASS -> FAIL [fdo#108145]

  * igt@kms_plane_multiple@atomic-pipe-c-tiling-x:
    - shard-glk:          PASS -> FAIL [fdo#103166] +2

  * igt@kms_rotation_crc@multiplane-rotation-cropping-top:
    - shard-apl:          PASS -> DMESG-WARN [fdo#108337]

  
#### Possible fixes ####

  * igt@i915_suspend@shrink:
    - shard-apl:          DMESG-WARN [fdo#107886] / [fdo#108784] -> SKIP

  * igt@kms_available_modes_crc@available_mode_test_crc:
    - shard-apl:          FAIL [fdo#106641] -> PASS

  * igt@kms_ccs@pipe-a-crc-sprite-planes-basic:
    - shard-glk:          FAIL [fdo#108145] -> PASS

  * igt@kms_color@pipe-c-ctm-max:
    - shard-apl:          FAIL [fdo#108147] -> PASS

  * igt@kms_cursor_crc@cursor-128x128-suspend:
    - shard-apl:          FAIL [fdo#103191] / [fdo#103232] -> PASS +1

  * igt@kms_cursor_crc@cursor-128x42-onscreen:
    - shard-apl:          FAIL [fdo#103232] -> PASS +2

  * igt@kms_cursor_legacy@flip-vs-cursor-legacy:
    - shard-apl:          DMESG-WARN [fdo#103558] / [fdo#105602] -> PASS +15

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-pwrite:
    - shard-apl:          FAIL [fdo#103167] -> PASS +2

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-draw-mmap-cpu:
    - shard-glk:          FAIL [fdo#103167] -> PASS +4

  * igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-gtt:
    - shard-kbl:          DMESG-WARN [fdo#103313] / [fdo#103558] / [fdo#105602] -> PASS +1

  * igt@kms_plane@pixel-format-pipe-c-planes-source-clamping:
    - shard-apl:          FAIL [fdo#108948] -> PASS +1

  * igt@kms_plane_multiple@atomic-pipe-a-tiling-y:
    - shard-glk:          FAIL [fdo#103166] -> PASS +3
    - shard-apl:          FAIL [fdo#103166] -> PASS +1

  * igt@kms_plane_multiple@atomic-pipe-b-tiling-yf:
    - shard-kbl:          FAIL [fdo#103166] -> PASS

  * igt@kms_plane_multiple@atomic-pipe-c-tiling-yf:
    - shard-apl:          DMESG-FAIL [fdo#103166] / [fdo#103558] / [fdo#105602] -> PASS
    - shard-kbl:          DMESG-FAIL [fdo#103166] / [fdo#103558] / [fdo#105602] -> PASS

  * igt@kms_vblank@pipe-a-ts-continuation-dpms-suspend:
    - shard-kbl:          INCOMPLETE [fdo#103665] -> PASS

  * igt@kms_vblank@pipe-a-ts-continuation-modeset-hang:
    - shard-kbl:          DMESG-WARN [fdo#103558] / [fdo#105602] -> PASS +13

  * igt@pm_rps@min-max-config-loaded:
    - shard-glk:          FAIL [fdo#102250] -> PASS

  
#### Warnings ####

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-cur-indfb-move:
    - shard-kbl:          DMESG-WARN [fdo#103558] / [fdo#105602] -> FAIL [fdo#103167]
    - shard-apl:          DMESG-WARN [fdo#103558] / [fdo#105602] -> FAIL [fdo#103167]

  * igt@kms_plane_alpha_blend@pipe-a-alpha-opaque-fb:
    - shard-apl:          DMESG-FAIL [fdo#103558] / [fdo#105602] / [fdo#108145] -> FAIL [fdo#108145]
    - shard-kbl:          DMESG-FAIL [fdo#103558] / [fdo#105602] / [fdo#108145] -> FAIL [fdo#108145]

  * igt@kms_rotation_crc@multiplane-rotation-cropping-top:
    - shard-kbl:          DMESG-FAIL [fdo#108950] -> DMESG-WARN [fdo#105604]

  
  [fdo#102250]: https://bugs.freedesktop.org/show_bug.cgi?id=102250
  [fdo#103166]: https://bugs.freedesktop.org/show_bug.cgi?id=103166
  [fdo#103167]: https://bugs.freedesktop.org/show_bug.cgi?id=103167
  [fdo#103191]: https://bugs.freedesktop.org/show_bug.cgi?id=103191
  [fdo#103232]: https://bugs.freedesktop.org/show_bug.cgi?id=103232
  [fdo#103313]: https://bugs.freedesktop.org/show_bug.cgi?id=103313
  [fdo#103558]: https://bugs.freedesktop.org/show_bug.cgi?id=103558
  [fdo#103665]: https://bugs.freedesktop.org/show_bug.cgi?id=103665
  [fdo#105363]: https://bugs.freedesktop.org/show_bug.cgi?id=105363
  [fdo#105602]: https://bugs.freedesktop.org/show_bug.cgi?id=105602
  [fdo#105604]: https://bugs.freedesktop.org/show_bug.cgi?id=105604
  [fdo#105682]: https://bugs.freedesktop.org/show_bug.cgi?id=105682
  [fdo#106641]: https://bugs.freedesktop.org/show_bug.cgi?id=106641
  [fdo#107886]: https://bugs.freedesktop.org/show_bug.cgi?id=107886
  [fdo#107956]: https://bugs.freedesktop.org/show_bug.cgi?id=107956
  [fdo#108145]: https://bugs.freedesktop.org/show_bug.cgi?id=108145
  [fdo#108147]: https://bugs.freedesktop.org/show_bug.cgi?id=108147
  [fdo#108337]: https://bugs.freedesktop.org/show_bug.cgi?id=108337
  [fdo#108784]: https://bugs.freedesktop.org/show_bug.cgi?id=108784
  [fdo#108948]: https://bugs.freedesktop.org/show_bug.cgi?id=108948
  [fdo#108950]: https://bugs.freedesktop.org/show_bug.cgi?id=108950


Participating hosts (7 -> 5)
------------------------------

  Missing    (2): shard-skl shard-iclb 


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

    * IGT: IGT_4756 -> IGTPW_2185
    * Piglit: piglit_4509 -> None

  CI_DRM_5363: f141806c68e4cbd56e3a5a582eb1a6f5b7edfc84 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_2185: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2185/
  IGT_4756: 75081c6bfb9998bd7cbf35a7ac0578c683fe55a8 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
  piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2185/
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Petri Latvala]

On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
> diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
> index 73d127603d28..d76a4b3b1c71 100644
> --- a/tests/intel-ci/blacklist.txt
> +++ b/tests/intel-ci/blacklist.txt
> @@ -60,6 +60,7 @@ igt@gem_ring_sync_copy(@.*)?
>  igt@gem_ring_sync_loop(@.*)?
>  igt@gem_seqno_wrap(@.*)?
>  igt@gem_shrink@(?!reclaim$).*
> +igt@gem_shrink@(?!reclaims-and-oom).*
>  igt@gem_softpin@.*(hang|S4).*
>  igt@gem_spin_batch(@.*)?
>  igt@gem_stolen@.*hibernate.*


In case you didn't notice: The first gem_shrink line removes the
reclaims-and-oom* subtests, and the second line (the one you added)
then removes the 'reclaim' subtest, resulting in all gem_shrink
subtests blacklisted.


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

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Tvrtko Ursulin]

On 07/01/2019 11:01, Petri Latvala wrote:
> On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
>> diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
>> index 73d127603d28..d76a4b3b1c71 100644
>> --- a/tests/intel-ci/blacklist.txt
>> +++ b/tests/intel-ci/blacklist.txt
>> @@ -60,6 +60,7 @@ igt@gem_ring_sync_copy(@.*)?
>>   igt@gem_ring_sync_loop(@.*)?
>>   igt@gem_seqno_wrap(@.*)?
>>   igt@gem_shrink@(?!reclaim$).*
>> +igt@gem_shrink@(?!reclaims-and-oom).*
>>   igt@gem_softpin@.*(hang|S4).*
>>   igt@gem_spin_batch(@.*)?
>>   igt@gem_stolen@.*hibernate.*
> 
> 
> In case you didn't notice: The first gem_shrink line removes the
> reclaims-and-oom* subtests, and the second line (the one you added)
> then removes the 'reclaim' subtest, resulting in all gem_shrink
> subtests blacklisted.

No I haven't thank you. Interestingly the reclaim subtest still did run. 
Okay, but in essence should this work then:

   igt@gem_shrink@(?!reclaim).*

To blacklist everything apart from reclaims and reclaims-and-oom.* subtests?

Regards,

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

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Petri Latvala]

On Mon, Jan 07, 2019 at 11:12:30AM +0000, Tvrtko Ursulin wrote:
> 
> On 07/01/2019 11:01, Petri Latvala wrote:
> > On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
> > > diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
> > > index 73d127603d28..d76a4b3b1c71 100644
> > > --- a/tests/intel-ci/blacklist.txt
> > > +++ b/tests/intel-ci/blacklist.txt
> > > @@ -60,6 +60,7 @@ igt@gem_ring_sync_copy(@.*)?
> > >   igt@gem_ring_sync_loop(@.*)?
> > >   igt@gem_seqno_wrap(@.*)?
> > >   igt@gem_shrink@(?!reclaim$).*
> > > +igt@gem_shrink@(?!reclaims-and-oom).*
> > >   igt@gem_softpin@.*(hang|S4).*
> > >   igt@gem_spin_batch(@.*)?
> > >   igt@gem_stolen@.*hibernate.*
> > 
> > 
> > In case you didn't notice: The first gem_shrink line removes the
> > reclaims-and-oom* subtests, and the second line (the one you added)
> > then removes the 'reclaim' subtest, resulting in all gem_shrink
> > subtests blacklisted.
> 
> No I haven't thank you. Interestingly the reclaim subtest still did run.

https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2185/shards-all.html
it's NOTRUN on all machines on patched IGT.

> Okay, but in essence should this work then:
> 
>   igt@gem_shrink@(?!reclaim).*
> 
> To blacklist everything apart from reclaims and reclaims-and-oom.*
> subtests?

Yeah that looks correct.


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

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Tvrtko Ursulin]

On 07/01/2019 11:28, Petri Latvala wrote:
> On Mon, Jan 07, 2019 at 11:12:30AM +0000, Tvrtko Ursulin wrote:
>>
>> On 07/01/2019 11:01, Petri Latvala wrote:
>>> On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
>>>> diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
>>>> index 73d127603d28..d76a4b3b1c71 100644
>>>> --- a/tests/intel-ci/blacklist.txt
>>>> +++ b/tests/intel-ci/blacklist.txt
>>>> @@ -60,6 +60,7 @@ igt@gem_ring_sync_copy(@.*)?
>>>>    igt@gem_ring_sync_loop(@.*)?
>>>>    igt@gem_seqno_wrap(@.*)?
>>>>    igt@gem_shrink@(?!reclaim$).*
>>>> +igt@gem_shrink@(?!reclaims-and-oom).*
>>>>    igt@gem_softpin@.*(hang|S4).*
>>>>    igt@gem_spin_batch(@.*)?
>>>>    igt@gem_stolen@.*hibernate.*
>>>
>>>
>>> In case you didn't notice: The first gem_shrink line removes the
>>> reclaims-and-oom* subtests, and the second line (the one you added)
>>> then removes the 'reclaim' subtest, resulting in all gem_shrink
>>> subtests blacklisted.
>>
>> No I haven't thank you. Interestingly the reclaim subtest still did run.
> 
> https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2185/shards-all.html
> it's NOTRUN on all machines on patched IGT.

My fail while looking at the pages.. I saw the test mentioned in the 
list but fail to spot that was only because it was run in the baseline. :I

>> Okay, but in essence should this work then:
>>
>>    igt@gem_shrink@(?!reclaim).*
>>
>> To blacklist everything apart from reclaims and reclaims-and-oom.*
>> subtests?
> 
> Yeah that looks correct.

Thanks, I'll send a v2 shortly.

Regards,

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

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Michał Winiarski]

On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> A set of subtests which exercises different paths to our shrinker code
> (including the OOM killer) in predictable and reasonable time budget.
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> ---
>  lib/igt_core.c                        |  19 ++
>  lib/igt_core.h                        |   1 +
>  tests/i915/gem_shrink.c               | 399 ++++++++++++++++++++++++++
>  tests/intel-ci/blacklist.txt          |   1 +
>  tests/intel-ci/fast-feedback.testlist |   3 +
>  5 files changed, 423 insertions(+)

[snip]

> diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
> index c8e05814ee70..7c002de0ef1f 100644
> --- a/tests/i915/gem_shrink.c
> +++ b/tests/i915/gem_shrink.c
> @@ -26,6 +26,10 @@
>   *
>   * Exercise the shrinker by overallocating GEM objects
>   */
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <sys/wait.h>
> +#include <fcntl.h>
>  
>  #include "igt.h"
>  #include "igt_gt.h"
> @@ -366,6 +370,376 @@ static void reclaim(unsigned engine, int timeout)
>  	close(fd);
>  }
>  
> +static unsigned long get_meminfo(const char *info, const char *tag)
> +{
> +	const char *str;
> +	unsigned long val;
> +
> +	str = strstr(info, tag);
> +	if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
> +		return val >> 10;
> +
> +	igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
> +	return 0;
> +}
> +
> +static unsigned long get_avail_ram_mb(void)
> +{
> +	int fd;
> +	int ret;
> +	char buf[4096];
> +	unsigned long ram;
> +
> +	fd = open("/proc/meminfo", O_RDONLY);
> +	igt_assert_fd(fd);
> +
> +	ret = read(fd, buf, sizeof(buf));
> +	igt_assert(ret >= 0);
> +
> +	close(fd);
> +
> +	ram = get_meminfo(buf, "MemAvailable:");
> +	ram += get_meminfo(buf, "Buffers:");
> +	ram += get_meminfo(buf, "Cached:");
> +	ram += get_meminfo(buf, "SwapCached:");
> +
> +	return ram;
> +}

What's wrong with ones from intel_os.c?

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

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Chris Wilson]

Quoting Michał Winiarski (2019-01-07 12:27:07)
> On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
> > From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> > 
> > A set of subtests which exercises different paths to our shrinker code
> > (including the OOM killer) in predictable and reasonable time budget.
> > 
> > Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> > ---
> >  lib/igt_core.c                        |  19 ++
> >  lib/igt_core.h                        |   1 +
> >  tests/i915/gem_shrink.c               | 399 ++++++++++++++++++++++++++
> >  tests/intel-ci/blacklist.txt          |   1 +
> >  tests/intel-ci/fast-feedback.testlist |   3 +
> >  5 files changed, 423 insertions(+)
> 
> [snip]
> 
> > diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
> > index c8e05814ee70..7c002de0ef1f 100644
> > --- a/tests/i915/gem_shrink.c
> > +++ b/tests/i915/gem_shrink.c
> > @@ -26,6 +26,10 @@
> >   *
> >   * Exercise the shrinker by overallocating GEM objects
> >   */
> > +#include <sys/types.h>
> > +#include <sys/stat.h>
> > +#include <sys/wait.h>
> > +#include <fcntl.h>
> >  
> >  #include "igt.h"
> >  #include "igt_gt.h"
> > @@ -366,6 +370,376 @@ static void reclaim(unsigned engine, int timeout)
> >       close(fd);
> >  }
> >  
> > +static unsigned long get_meminfo(const char *info, const char *tag)
> > +{
> > +     const char *str;
> > +     unsigned long val;
> > +
> > +     str = strstr(info, tag);
> > +     if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
> > +             return val >> 10;
> > +
> > +     igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
> > +     return 0;
> > +}
> > +
> > +static unsigned long get_avail_ram_mb(void)
> > +{
> > +     int fd;
> > +     int ret;
> > +     char buf[4096];
> > +     unsigned long ram;
> > +
> > +     fd = open("/proc/meminfo", O_RDONLY);
> > +     igt_assert_fd(fd);
> > +
> > +     ret = read(fd, buf, sizeof(buf));
> > +     igt_assert(ret >= 0);
> > +
> > +     close(fd);
> > +
> > +     ram = get_meminfo(buf, "MemAvailable:");
> > +     ram += get_meminfo(buf, "Buffers:");
> > +     ram += get_meminfo(buf, "Cached:");
> > +     ram += get_meminfo(buf, "SwapCached:");
> > +
> > +     return ram;
> > +}
> 
> What's wrong with ones from intel_os.c?

They pull in both an i915 and mm purge, which iirc, had to be avoided
here.
-Chris
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Tvrtko Ursulin]

On 07/01/2019 12:31, Chris Wilson wrote:
> Quoting Michał Winiarski (2019-01-07 12:27:07)
>> On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
>>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>>
>>> A set of subtests which exercises different paths to our shrinker code
>>> (including the OOM killer) in predictable and reasonable time budget.
>>>
>>> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>> ---
>>>   lib/igt_core.c                        |  19 ++
>>>   lib/igt_core.h                        |   1 +
>>>   tests/i915/gem_shrink.c               | 399 ++++++++++++++++++++++++++
>>>   tests/intel-ci/blacklist.txt          |   1 +
>>>   tests/intel-ci/fast-feedback.testlist |   3 +
>>>   5 files changed, 423 insertions(+)
>>
>> [snip]
>>
>>> diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
>>> index c8e05814ee70..7c002de0ef1f 100644
>>> --- a/tests/i915/gem_shrink.c
>>> +++ b/tests/i915/gem_shrink.c
>>> @@ -26,6 +26,10 @@
>>>    *
>>>    * Exercise the shrinker by overallocating GEM objects
>>>    */
>>> +#include <sys/types.h>
>>> +#include <sys/stat.h>
>>> +#include <sys/wait.h>
>>> +#include <fcntl.h>
>>>   
>>>   #include "igt.h"
>>>   #include "igt_gt.h"
>>> @@ -366,6 +370,376 @@ static void reclaim(unsigned engine, int timeout)
>>>        close(fd);
>>>   }
>>>   
>>> +static unsigned long get_meminfo(const char *info, const char *tag)
>>> +{
>>> +     const char *str;
>>> +     unsigned long val;
>>> +
>>> +     str = strstr(info, tag);
>>> +     if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
>>> +             return val >> 10;
>>> +
>>> +     igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
>>> +     return 0;
>>> +}
>>> +
>>> +static unsigned long get_avail_ram_mb(void)
>>> +{
>>> +     int fd;
>>> +     int ret;
>>> +     char buf[4096];
>>> +     unsigned long ram;
>>> +
>>> +     fd = open("/proc/meminfo", O_RDONLY);
>>> +     igt_assert_fd(fd);
>>> +
>>> +     ret = read(fd, buf, sizeof(buf));
>>> +     igt_assert(ret >= 0);
>>> +
>>> +     close(fd);
>>> +
>>> +     ram = get_meminfo(buf, "MemAvailable:");
>>> +     ram += get_meminfo(buf, "Buffers:");
>>> +     ram += get_meminfo(buf, "Cached:");
>>> +     ram += get_meminfo(buf, "SwapCached:");
>>> +
>>> +     return ram;
>>> +}
>>
>> What's wrong with ones from intel_os.c?
> 
> They pull in both an i915 and mm purge, which iirc, had to be avoided
> here.

Yep. I can sense a suggestion of adding a lighter weight version to the 
library now.. :)

Regards,

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

Re: [igt-dev] [PATCH i-g-t] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Chris Wilson]

Quoting Tvrtko Ursulin (2019-01-07 12:52:28)
> 
> On 07/01/2019 12:31, Chris Wilson wrote:
> > Quoting Michał Winiarski (2019-01-07 12:27:07)
> >> On Fri, Jan 04, 2019 at 03:37:09PM +0000, Tvrtko Ursulin wrote:
> >>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> >>>
> >>> A set of subtests which exercises different paths to our shrinker code
> >>> (including the OOM killer) in predictable and reasonable time budget.
> >>>
> >>> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> >>> ---
> >>>   lib/igt_core.c                        |  19 ++
> >>>   lib/igt_core.h                        |   1 +
> >>>   tests/i915/gem_shrink.c               | 399 ++++++++++++++++++++++++++
> >>>   tests/intel-ci/blacklist.txt          |   1 +
> >>>   tests/intel-ci/fast-feedback.testlist |   3 +
> >>>   5 files changed, 423 insertions(+)
> >>
> >> [snip]
> >>
> >>> diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
> >>> index c8e05814ee70..7c002de0ef1f 100644
> >>> --- a/tests/i915/gem_shrink.c
> >>> +++ b/tests/i915/gem_shrink.c
> >>> @@ -26,6 +26,10 @@
> >>>    *
> >>>    * Exercise the shrinker by overallocating GEM objects
> >>>    */
> >>> +#include <sys/types.h>
> >>> +#include <sys/stat.h>
> >>> +#include <sys/wait.h>
> >>> +#include <fcntl.h>
> >>>   
> >>>   #include "igt.h"
> >>>   #include "igt_gt.h"
> >>> @@ -366,6 +370,376 @@ static void reclaim(unsigned engine, int timeout)
> >>>        close(fd);
> >>>   }
> >>>   
> >>> +static unsigned long get_meminfo(const char *info, const char *tag)
> >>> +{
> >>> +     const char *str;
> >>> +     unsigned long val;
> >>> +
> >>> +     str = strstr(info, tag);
> >>> +     if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
> >>> +             return val >> 10;
> >>> +
> >>> +     igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
> >>> +     return 0;
> >>> +}
> >>> +
> >>> +static unsigned long get_avail_ram_mb(void)
> >>> +{
> >>> +     int fd;
> >>> +     int ret;
> >>> +     char buf[4096];
> >>> +     unsigned long ram;
> >>> +
> >>> +     fd = open("/proc/meminfo", O_RDONLY);
> >>> +     igt_assert_fd(fd);
> >>> +
> >>> +     ret = read(fd, buf, sizeof(buf));
> >>> +     igt_assert(ret >= 0);
> >>> +
> >>> +     close(fd);
> >>> +
> >>> +     ram = get_meminfo(buf, "MemAvailable:");
> >>> +     ram += get_meminfo(buf, "Buffers:");
> >>> +     ram += get_meminfo(buf, "Cached:");
> >>> +     ram += get_meminfo(buf, "SwapCached:");
> >>> +
> >>> +     return ram;
> >>> +}
> >>
> >> What's wrong with ones from intel_os.c?
> > 
> > They pull in both an i915 and mm purge, which iirc, had to be avoided
> > here.
> 
> Yep. I can sense a suggestion of adding a lighter weight version to the 
> library now.. :)

Nah, I refrained because I hope for the same leniency (many times over).
Anyway, the third user has to refactor ;)

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

[igt-dev] [PATCH i-g-t v2] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

A set of subtests which exercises different paths to our shrinker code
(including the OOM killer) in predictable and reasonable time budget.

v2:
 * Fix blacklist regexp. (Petri Latvala)

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 lib/igt_core.c                        |  19 ++
 lib/igt_core.h                        |   1 +
 tests/i915/gem_shrink.c               | 399 ++++++++++++++++++++++++++
 tests/intel-ci/blacklist.txt          |   2 +-
 tests/intel-ci/fast-feedback.testlist |   3 +
 5 files changed, 423 insertions(+), 1 deletion(-)

diff --git a/lib/igt_core.c b/lib/igt_core.c
index 50d6008f6c82..351da0b4e020 100644
--- a/lib/igt_core.c
+++ b/lib/igt_core.c
@@ -1685,6 +1685,25 @@ void igt_stop_helper(struct igt_helper_process *proc)
 	assert(helper_was_alive(proc, status));
 }
 
+/**
+ * igt_try_stop_helper:
+ * @proc: #igt_helper_process structure
+ *
+ * Terminates a helper process if it is still running and returns true, or false
+ * if the process wasn't running.
+ */
+bool igt_try_stop_helper(struct igt_helper_process *proc)
+{
+	int status;
+
+	/* failure here means the pid is already dead and so waiting is safe */
+	kill(proc->pid, proc->use_SIGKILL ? SIGKILL : SIGTERM);
+
+	status = igt_wait_helper(proc);
+
+	return helper_was_alive(proc, status);
+}
+
 static void children_exit_handler(int sig)
 {
 	int status;
diff --git a/lib/igt_core.h b/lib/igt_core.h
index 6f8c3852a686..ed5ceebf1205 100644
--- a/lib/igt_core.h
+++ b/lib/igt_core.h
@@ -795,6 +795,7 @@ bool __igt_fork_helper(struct igt_helper_process *proc);
 	for (; __igt_fork_helper(proc); exit(0))
 int igt_wait_helper(struct igt_helper_process *proc);
 void igt_stop_helper(struct igt_helper_process *proc);
+bool igt_try_stop_helper(struct igt_helper_process *proc);
 
 /* exit handler code */
 
diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
index c8e05814ee70..7c002de0ef1f 100644
--- a/tests/i915/gem_shrink.c
+++ b/tests/i915/gem_shrink.c
@@ -26,6 +26,10 @@
  *
  * Exercise the shrinker by overallocating GEM objects
  */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>
 
 #include "igt.h"
 #include "igt_gt.h"
@@ -366,6 +370,376 @@ static void reclaim(unsigned engine, int timeout)
 	close(fd);
 }
 
+static unsigned long get_meminfo(const char *info, const char *tag)
+{
+	const char *str;
+	unsigned long val;
+
+	str = strstr(info, tag);
+	if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
+		return val >> 10;
+
+	igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
+	return 0;
+}
+
+static unsigned long get_avail_ram_mb(void)
+{
+	int fd;
+	int ret;
+	char buf[4096];
+	unsigned long ram;
+
+	fd = open("/proc/meminfo", O_RDONLY);
+	igt_assert_fd(fd);
+
+	ret = read(fd, buf, sizeof(buf));
+	igt_assert(ret >= 0);
+
+	close(fd);
+
+	ram = get_meminfo(buf, "MemAvailable:");
+	ram += get_meminfo(buf, "Buffers:");
+	ram += get_meminfo(buf, "Cached:");
+	ram += get_meminfo(buf, "SwapCached:");
+
+	return ram;
+}
+
+struct test {
+#define TEST_BO		(1)
+#define TEST_USERPTR	(2)
+	unsigned int flags;
+	int fd;
+};
+
+static uint32_t __get_pages(int fd, unsigned long alloc)
+{
+	uint32_t handle = gem_create(fd, alloc);
+
+	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
+	gem_madvise(fd, handle, I915_MADV_DONTNEED);
+
+	return handle;
+}
+
+struct test_obj {
+	void *ptr;
+	uint32_t handle;
+};
+
+#define PAGE_SIZE 4096
+static void
+__get_userptr(int fd, struct test_obj *obj, unsigned long sz)
+{
+	struct local_i915_gem_userptr userptr = { };
+	void *ptr;
+
+	igt_assert_eq(sz & 4095, 0);
+
+	ptr = mmap(NULL, sz, PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	for (size_t page = 0; page < sz; page += PAGE_SIZE)
+		*(volatile uint32_t *)((unsigned char *)ptr + page) = 0;
+
+	userptr.user_size = sz;
+	userptr.user_ptr = to_user_pointer(ptr);
+	do_ioctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+
+	gem_set_domain(fd, userptr.handle, I915_GEM_DOMAIN_GTT, 0);
+	gem_madvise(fd, userptr.handle, I915_MADV_DONTNEED);
+
+	obj->ptr = ptr;
+	obj->handle = userptr.handle;
+}
+
+/*
+ * Use a specific way of using up memory until we are below a certain threshold.
+ */
+static void *mempressure(void *arg)
+{
+	const unsigned int free_threshold_mb = 256;
+	struct test_obj *list = NULL;
+	struct test *test = arg;
+	const unsigned int sz_mb = 2;
+	const unsigned int sz = sz_mb << 20;
+	unsigned int n = 0, max = 0;
+	unsigned int blocks;
+
+	for (;;) {
+		unsigned long ram_mb = get_avail_ram_mb();
+
+		if (!list) {
+			/*
+			 * On first pass estimate how many sz_mb sized blocks
+			 * we could need to use up all RAM.
+			 */
+			blocks = ram_mb / sz_mb;
+			list = calloc(blocks, sizeof(*list));
+			igt_assert(list);
+		} else if (ram_mb < free_threshold_mb) {
+			/* Limit the working set once under the threshold. */
+			blocks = max + 1;
+		}
+
+		/* Free the oldest block once the working set wrapped. */
+		if (list[n].ptr || list[n].handle) {
+			if (test->flags & TEST_USERPTR) {
+				munmap(list[n].ptr, sz);
+				gem_close(test->fd, list[n].handle);
+			} else if (test->flags & TEST_BO) {
+				gem_close(test->fd, list[n].handle);
+			} else {
+				munmap(list[n].ptr, sz);
+			}
+		}
+
+		/*
+		 * Allocate memory blocks and record the current working set
+		 * size.
+		 */
+		if (test->flags & TEST_BO) {
+			list[n].handle = __get_pages(test->fd, sz);
+		} else if (test->flags & TEST_USERPTR) {
+			__get_userptr(test->fd, &list[n], sz);
+		} else {
+			list[n].ptr = mmap(NULL, sz, PROT_WRITE,
+					   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+			assert(list[n].ptr != MAP_FAILED);
+
+			madvise(list[n].ptr, sz, MADV_HUGEPAGE);
+
+			for (size_t page = 0; page < sz; page += PAGE_SIZE)
+				*(volatile uint32_t *)((unsigned char *)list[n].ptr + page) = 0;
+		}
+
+		if (n > max)
+			max = n;
+
+		n++;
+
+		/*
+		 * Start freeing the oldest and reallocating once maximum
+		 * working set size has been reached.
+		 */
+		if (n >= blocks)
+			n = 0;
+	}
+
+	return NULL;
+}
+
+static void oom_adjust(const char *score)
+{
+	int fd;
+
+	fd = open("/proc/self/oom_score_adj", O_WRONLY);
+	igt_assert_fd(fd);
+	igt_assert(write(fd, score, sizeof(score)) == sizeof(score));
+	close(fd);
+}
+
+static void trigger_oom(void)
+{
+	const char *cmd = "f";
+	int fd;
+
+	fd = open("/proc/sysrq-trigger", O_WRONLY);
+	igt_assert_fd(fd);
+	igt_assert(write(fd, cmd, sizeof(cmd)) == sizeof(cmd));
+	close(fd);
+}
+
+static bool has_sysrq_trigger(void)
+{
+	int fd;
+
+	fd = open("/proc/sysrq-trigger", O_WRONLY);
+	close(fd);
+
+	return fd >= 0;
+}
+
+/*
+ * Exercise different paths to our shrinker code, including OOM, in predictable
+ * and reasonable time budget.
+ */
+static void reclaim_oom(unsigned int flags, unsigned int passes)
+{
+	unsigned int count = 0;
+
+	oom_adjust("-1000");
+
+	do {
+		struct igt_helper_process gem_child = { .use_SIGKILL = true };
+		struct igt_helper_process mem_child = { .use_SIGKILL = true };
+		struct igt_helper_process eb_child = { .use_SIGKILL = true };
+		struct igt_helper_process drop_child = { .use_SIGKILL = true };
+
+		igt_debug("Iteration %u...\n", ++count);
+
+		/*
+		 * Apply either anon backed or shmem backed memory pressure
+		 * to the amount to use up almost all available RAM.
+		 */
+		igt_fork_helper(&mem_child) {
+			struct test test = { };
+
+			if ((flags & (TEST_BO | TEST_USERPTR)) ==
+			    (TEST_BO | TEST_USERPTR))
+				test.flags = TEST_BO;
+
+			/* Sacrifice the memory hog if it comes to that. */
+			oom_adjust("500");
+
+			if (test.flags == TEST_BO) {
+				test.fd = drm_open_driver_render(DRIVER_INTEL);
+				igt_require_gem(test.fd);
+			}
+
+			mempressure(&test);
+
+			if (test.flags == TEST_BO)
+				close(test.fd);
+		}
+
+		/*
+		 * Apply either userptr backed or shmem backed memory pressure
+		 * to the amount to use up almost all available RAM.
+		 */
+		igt_fork_helper(&gem_child) {
+			struct test test = { .flags = flags };
+
+			if ((flags & (TEST_BO | TEST_USERPTR)) ==
+			    (TEST_BO | TEST_USERPTR))
+				test.flags = TEST_USERPTR;
+
+			/* Sacrifice the memory hog if it comes to that. */
+			oom_adjust("500");
+
+			test.fd = drm_open_driver_render(DRIVER_INTEL);
+			igt_require_gem(test.fd);
+
+			mempressure(&test);
+
+			close(test.fd);
+		}
+
+		/*
+		 * Apply an execbuf load to exercise the request allocation and
+		 * direct reclaim from this path.
+		 *
+		 * Occasionaly sync with execution and pause for a little bit to
+		 * avoid hogging to much from this client.
+		 */
+		igt_fork_helper(&eb_child) {
+			struct test test = { .flags = flags };
+			const uint32_t bbe = MI_BATCH_BUFFER_END;
+			struct drm_i915_gem_exec_object2 obj = { };
+			struct drm_i915_gem_execbuffer2 execbuf = { };
+
+			execbuf.buffers_ptr = to_user_pointer(&obj);
+			execbuf.buffer_count = 1;
+
+			test.fd = drm_open_driver_render(DRIVER_INTEL);
+			igt_require_gem(test.fd);
+
+			for (;;) {
+				unsigned long eb = 0;
+				struct timespec ts = { };
+				unsigned long start;
+
+				igt_nsec_elapsed(&ts);
+				start = igt_nsec_elapsed(&ts) / 1e6;
+
+				for (;;) {
+					unsigned long now;
+
+					obj.handle = gem_create(test.fd, 4096);
+					gem_write(test.fd, obj.handle, 0, &bbe,
+						sizeof(bbe));
+					gem_execbuf(test.fd, &execbuf);
+					eb++;
+					now = igt_nsec_elapsed(&ts) / 1e6;
+					if (now > (start + 1000)) {
+						gem_sync(test.fd, obj.handle);
+						if (now > (start + 2000)) {
+							gem_close(test.fd,
+								  obj.handle);
+							break;
+						}
+					}
+					gem_close(test.fd, obj.handle);
+				}
+
+				igt_debug("%lu execbufs\n", eb);
+				usleep(500e3);
+			}
+
+			close(test.fd);
+		}
+
+		/*
+		 * Manually drop cached with the DROP_ACTIVE flag set every now
+		 * and then in order to exercise this path as well.
+		 */
+		igt_fork_helper(&drop_child) {
+			int fd;
+
+			fd = drm_open_driver(DRIVER_INTEL);
+			igt_require_gem(fd);
+
+			for (;;) {
+				usleep(334e3);
+				igt_debug("Dropping caches...\n");
+				igt_drop_caches_set(fd, DROP_ACTIVE);
+			}
+
+			close(fd);
+		}
+
+		/*
+		 * When memory pressure clients have managed to use up all
+		 * available RAM, let them run for a brief moment yet and then
+		 * manually trigger the OOM condition.
+		 */
+		for (unsigned long ram_mb = 0;
+		     (ram_mb = get_avail_ram_mb()) > 512;) {
+			int status;
+			pid_t pid;
+
+			igt_debug("[%u] %lu MiB free\n", count, ram_mb);
+
+			pid = waitpid(mem_child.pid, &status, WNOHANG);
+			if (pid)
+				break;
+
+			pid = waitpid(gem_child.pid, &status, WNOHANG);
+			if (pid)
+				break;
+
+			pid = waitpid(eb_child.pid, &status, WNOHANG);
+			igt_assert_eq(pid, 0);
+
+			pid = waitpid(drop_child.pid, &status, WNOHANG);
+			igt_assert_eq(pid, 0);
+
+			sleep(1);
+		}
+
+		igt_debug("Triggering OOM...\n");
+		trigger_oom();
+
+		sleep(1);
+
+		igt_try_stop_helper(&mem_child);
+		igt_try_stop_helper(&gem_child);
+		igt_stop_helper(&eb_child);
+		igt_stop_helper(&drop_child);
+	} while (count < passes);
+}
+
 igt_main
 {
 	const struct test {
@@ -432,6 +806,31 @@ igt_main
 	igt_subtest("reclaim")
 		reclaim(I915_EXEC_DEFAULT, 2);
 
+	igt_subtest_group {
+		struct {
+			const char *name;
+			unsigned int flags;
+			unsigned int passes;
+		} *p, passes[] = {
+			{ "reclaims-and-oom-basic", TEST_BO, 1 },
+			{ "reclaims-and-oom", TEST_BO, 3 },
+			{ "reclaims-and-oom-userptr-basic", TEST_USERPTR, 1 },
+			{ "reclaims-and-oom-userptr", TEST_USERPTR, 3 },
+			{ "reclaims-and-oom-both-basic", TEST_BO | TEST_USERPTR, 1 },
+			{ "reclaims-and-oom-both", TEST_BO | TEST_USERPTR, 3 },
+			{ NULL, 0, 0 },
+		};
+
+		igt_fixture {
+			igt_require(has_sysrq_trigger());
+		}
+
+		for (p = passes; p->name; p++) {
+			igt_subtest(p->name)
+				reclaim_oom(p->flags, p->passes);
+		}
+	}
+
 	for(const struct test *t = tests; t->name; t++) {
 		for(const struct mode *m = modes; m->suffix; m++) {
 			igt_subtest_f("%s%s", t->name, m->suffix)
diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
index 73d127603d28..b6e302db381e 100644
--- a/tests/intel-ci/blacklist.txt
+++ b/tests/intel-ci/blacklist.txt
@@ -59,7 +59,7 @@ igt@gem_ringfill@(?!.*basic).*
 igt@gem_ring_sync_copy(@.*)?
 igt@gem_ring_sync_loop(@.*)?
 igt@gem_seqno_wrap(@.*)?
-igt@gem_shrink@(?!reclaim$).*
+igt@gem_shrink@(?!reclaim).*
 igt@gem_softpin@.*(hang|S4).*
 igt@gem_spin_batch(@.*)?
 igt@gem_stolen@.*hibernate.*
diff --git a/tests/intel-ci/fast-feedback.testlist b/tests/intel-ci/fast-feedback.testlist
index 6d42792c67f7..0df7cc2fd9fd 100644
--- a/tests/intel-ci/fast-feedback.testlist
+++ b/tests/intel-ci/fast-feedback.testlist
@@ -124,6 +124,9 @@ igt@gem_ringfill@basic-default
 igt@gem_ringfill@basic-default-interruptible
 igt@gem_ringfill@basic-default-forked
 igt@gem_ringfill@basic-default-fd
+igt@gem_shrink@reclaims-and-oom-basic
+igt@gem_shrink@reclaims-and-oom-userptr-basic
+igt@gem_shrink@reclaims-and-oom-both-basic
 igt@gem_sync@basic-all
 igt@gem_sync@basic-each
 igt@gem_sync@basic-many-each
-- 
2.19.1

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

[igt-dev] [PATCH i-g-t v3] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

A set of subtests which exercises different paths to our shrinker code
(including the OOM killer) in predictable and reasonable time budget.

v2:
 * Fix blacklist regexp. (Petri Latvala)

v3:
 * Skip userptr test if not userptr support.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 lib/igt_core.c                        |  19 ++
 lib/igt_core.h                        |   1 +
 tests/i915/gem_shrink.c               | 401 ++++++++++++++++++++++++++
 tests/intel-ci/blacklist.txt          |   2 +-
 tests/intel-ci/fast-feedback.testlist |   3 +
 5 files changed, 425 insertions(+), 1 deletion(-)

diff --git a/lib/igt_core.c b/lib/igt_core.c
index 50d6008f6c82..351da0b4e020 100644
--- a/lib/igt_core.c
+++ b/lib/igt_core.c
@@ -1685,6 +1685,25 @@ void igt_stop_helper(struct igt_helper_process *proc)
 	assert(helper_was_alive(proc, status));
 }
 
+/**
+ * igt_try_stop_helper:
+ * @proc: #igt_helper_process structure
+ *
+ * Terminates a helper process if it is still running and returns true, or false
+ * if the process wasn't running.
+ */
+bool igt_try_stop_helper(struct igt_helper_process *proc)
+{
+	int status;
+
+	/* failure here means the pid is already dead and so waiting is safe */
+	kill(proc->pid, proc->use_SIGKILL ? SIGKILL : SIGTERM);
+
+	status = igt_wait_helper(proc);
+
+	return helper_was_alive(proc, status);
+}
+
 static void children_exit_handler(int sig)
 {
 	int status;
diff --git a/lib/igt_core.h b/lib/igt_core.h
index 6f8c3852a686..ed5ceebf1205 100644
--- a/lib/igt_core.h
+++ b/lib/igt_core.h
@@ -795,6 +795,7 @@ bool __igt_fork_helper(struct igt_helper_process *proc);
 	for (; __igt_fork_helper(proc); exit(0))
 int igt_wait_helper(struct igt_helper_process *proc);
 void igt_stop_helper(struct igt_helper_process *proc);
+bool igt_try_stop_helper(struct igt_helper_process *proc);
 
 /* exit handler code */
 
diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
index c8e05814ee70..3d48cbebc2f9 100644
--- a/tests/i915/gem_shrink.c
+++ b/tests/i915/gem_shrink.c
@@ -26,6 +26,10 @@
  *
  * Exercise the shrinker by overallocating GEM objects
  */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <fcntl.h>
 
 #include "igt.h"
 #include "igt_gt.h"
@@ -366,6 +370,378 @@ static void reclaim(unsigned engine, int timeout)
 	close(fd);
 }
 
+static unsigned long get_meminfo(const char *info, const char *tag)
+{
+	const char *str;
+	unsigned long val;
+
+	str = strstr(info, tag);
+	if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
+		return val >> 10;
+
+	igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
+	return 0;
+}
+
+static unsigned long get_avail_ram_mb(void)
+{
+	int fd;
+	int ret;
+	char buf[4096];
+	unsigned long ram;
+
+	fd = open("/proc/meminfo", O_RDONLY);
+	igt_assert_fd(fd);
+
+	ret = read(fd, buf, sizeof(buf));
+	igt_assert(ret >= 0);
+
+	close(fd);
+
+	ram = get_meminfo(buf, "MemAvailable:");
+	ram += get_meminfo(buf, "Buffers:");
+	ram += get_meminfo(buf, "Cached:");
+	ram += get_meminfo(buf, "SwapCached:");
+
+	return ram;
+}
+
+struct test {
+#define TEST_BO		(1)
+#define TEST_USERPTR	(2)
+	unsigned int flags;
+	int fd;
+};
+
+static uint32_t __get_pages(int fd, unsigned long alloc)
+{
+	uint32_t handle = gem_create(fd, alloc);
+
+	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
+	gem_madvise(fd, handle, I915_MADV_DONTNEED);
+
+	return handle;
+}
+
+struct test_obj {
+	void *ptr;
+	uint32_t handle;
+};
+
+#define PAGE_SIZE 4096
+static void
+__get_userptr(int fd, struct test_obj *obj, unsigned long sz)
+{
+	struct local_i915_gem_userptr userptr = { };
+	void *ptr;
+
+	igt_assert_eq(sz & 4095, 0);
+
+	ptr = mmap(NULL, sz, PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	assert(ptr != MAP_FAILED);
+
+	for (size_t page = 0; page < sz; page += PAGE_SIZE)
+		*(volatile uint32_t *)((unsigned char *)ptr + page) = 0;
+
+	userptr.user_size = sz;
+	userptr.user_ptr = to_user_pointer(ptr);
+	do_ioctl(fd, LOCAL_IOCTL_I915_GEM_USERPTR, &userptr);
+
+	gem_set_domain(fd, userptr.handle, I915_GEM_DOMAIN_GTT, 0);
+	gem_madvise(fd, userptr.handle, I915_MADV_DONTNEED);
+
+	obj->ptr = ptr;
+	obj->handle = userptr.handle;
+}
+
+/*
+ * Use a specific way of using up memory until we are below a certain threshold.
+ */
+static void *mempressure(void *arg)
+{
+	const unsigned int free_threshold_mb = 256;
+	struct test_obj *list = NULL;
+	struct test *test = arg;
+	const unsigned int sz_mb = 2;
+	const unsigned int sz = sz_mb << 20;
+	unsigned int n = 0, max = 0;
+	unsigned int blocks;
+
+	for (;;) {
+		unsigned long ram_mb = get_avail_ram_mb();
+
+		if (!list) {
+			/*
+			 * On first pass estimate how many sz_mb sized blocks
+			 * we could need to use up all RAM.
+			 */
+			blocks = ram_mb / sz_mb;
+			list = calloc(blocks, sizeof(*list));
+			igt_assert(list);
+		} else if (ram_mb < free_threshold_mb) {
+			/* Limit the working set once under the threshold. */
+			blocks = max + 1;
+		}
+
+		/* Free the oldest block once the working set wrapped. */
+		if (list[n].ptr || list[n].handle) {
+			if (test->flags & TEST_USERPTR) {
+				munmap(list[n].ptr, sz);
+				gem_close(test->fd, list[n].handle);
+			} else if (test->flags & TEST_BO) {
+				gem_close(test->fd, list[n].handle);
+			} else {
+				munmap(list[n].ptr, sz);
+			}
+		}
+
+		/*
+		 * Allocate memory blocks and record the current working set
+		 * size.
+		 */
+		if (test->flags & TEST_BO) {
+			list[n].handle = __get_pages(test->fd, sz);
+		} else if (test->flags & TEST_USERPTR) {
+			__get_userptr(test->fd, &list[n], sz);
+		} else {
+			list[n].ptr = mmap(NULL, sz, PROT_WRITE,
+					   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+			assert(list[n].ptr != MAP_FAILED);
+
+			madvise(list[n].ptr, sz, MADV_HUGEPAGE);
+
+			for (size_t page = 0; page < sz; page += PAGE_SIZE)
+				*(volatile uint32_t *)((unsigned char *)list[n].ptr + page) = 0;
+		}
+
+		if (n > max)
+			max = n;
+
+		n++;
+
+		/*
+		 * Start freeing the oldest and reallocating once maximum
+		 * working set size has been reached.
+		 */
+		if (n >= blocks)
+			n = 0;
+	}
+
+	return NULL;
+}
+
+static void oom_adjust(const char *score)
+{
+	int fd;
+
+	fd = open("/proc/self/oom_score_adj", O_WRONLY);
+	igt_assert_fd(fd);
+	igt_assert(write(fd, score, sizeof(score)) == sizeof(score));
+	close(fd);
+}
+
+static void trigger_oom(void)
+{
+	const char *cmd = "f";
+	int fd;
+
+	fd = open("/proc/sysrq-trigger", O_WRONLY);
+	igt_assert_fd(fd);
+	igt_assert(write(fd, cmd, sizeof(cmd)) == sizeof(cmd));
+	close(fd);
+}
+
+static bool has_sysrq_trigger(void)
+{
+	int fd;
+
+	fd = open("/proc/sysrq-trigger", O_WRONLY);
+	close(fd);
+
+	return fd >= 0;
+}
+
+/*
+ * Exercise different paths to our shrinker code, including OOM, in predictable
+ * and reasonable time budget.
+ */
+static void reclaim_oom(unsigned int flags, unsigned int passes)
+{
+	unsigned int count = 0;
+
+	igt_require(!(flags & TEST_USERPTR) || has_userptr());
+
+	oom_adjust("-1000");
+
+	do {
+		struct igt_helper_process gem_child = { .use_SIGKILL = true };
+		struct igt_helper_process mem_child = { .use_SIGKILL = true };
+		struct igt_helper_process eb_child = { .use_SIGKILL = true };
+		struct igt_helper_process drop_child = { .use_SIGKILL = true };
+
+		igt_debug("Iteration %u...\n", ++count);
+
+		/*
+		 * Apply either anon backed or shmem backed memory pressure
+		 * to the amount to use up almost all available RAM.
+		 */
+		igt_fork_helper(&mem_child) {
+			struct test test = { };
+
+			if ((flags & (TEST_BO | TEST_USERPTR)) ==
+			    (TEST_BO | TEST_USERPTR))
+				test.flags = TEST_BO;
+
+			/* Sacrifice the memory hog if it comes to that. */
+			oom_adjust("500");
+
+			if (test.flags == TEST_BO) {
+				test.fd = drm_open_driver_render(DRIVER_INTEL);
+				igt_require_gem(test.fd);
+			}
+
+			mempressure(&test);
+
+			if (test.flags == TEST_BO)
+				close(test.fd);
+		}
+
+		/*
+		 * Apply either userptr backed or shmem backed memory pressure
+		 * to the amount to use up almost all available RAM.
+		 */
+		igt_fork_helper(&gem_child) {
+			struct test test = { .flags = flags };
+
+			if ((flags & (TEST_BO | TEST_USERPTR)) ==
+			    (TEST_BO | TEST_USERPTR))
+				test.flags = TEST_USERPTR;
+
+			/* Sacrifice the memory hog if it comes to that. */
+			oom_adjust("500");
+
+			test.fd = drm_open_driver_render(DRIVER_INTEL);
+			igt_require_gem(test.fd);
+
+			mempressure(&test);
+
+			close(test.fd);
+		}
+
+		/*
+		 * Apply an execbuf load to exercise the request allocation and
+		 * direct reclaim from this path.
+		 *
+		 * Occasionaly sync with execution and pause for a little bit to
+		 * avoid hogging to much from this client.
+		 */
+		igt_fork_helper(&eb_child) {
+			struct test test = { .flags = flags };
+			const uint32_t bbe = MI_BATCH_BUFFER_END;
+			struct drm_i915_gem_exec_object2 obj = { };
+			struct drm_i915_gem_execbuffer2 execbuf = { };
+
+			execbuf.buffers_ptr = to_user_pointer(&obj);
+			execbuf.buffer_count = 1;
+
+			test.fd = drm_open_driver_render(DRIVER_INTEL);
+			igt_require_gem(test.fd);
+
+			for (;;) {
+				unsigned long eb = 0;
+				struct timespec ts = { };
+				unsigned long start;
+
+				igt_nsec_elapsed(&ts);
+				start = igt_nsec_elapsed(&ts) / 1e6;
+
+				for (;;) {
+					unsigned long now;
+
+					obj.handle = gem_create(test.fd, 4096);
+					gem_write(test.fd, obj.handle, 0, &bbe,
+						sizeof(bbe));
+					gem_execbuf(test.fd, &execbuf);
+					eb++;
+					now = igt_nsec_elapsed(&ts) / 1e6;
+					if (now > (start + 1000)) {
+						gem_sync(test.fd, obj.handle);
+						if (now > (start + 2000)) {
+							gem_close(test.fd,
+								  obj.handle);
+							break;
+						}
+					}
+					gem_close(test.fd, obj.handle);
+				}
+
+				igt_debug("%lu execbufs\n", eb);
+				usleep(500e3);
+			}
+
+			close(test.fd);
+		}
+
+		/*
+		 * Manually drop cached with the DROP_ACTIVE flag set every now
+		 * and then in order to exercise this path as well.
+		 */
+		igt_fork_helper(&drop_child) {
+			int fd;
+
+			fd = drm_open_driver(DRIVER_INTEL);
+			igt_require_gem(fd);
+
+			for (;;) {
+				usleep(334e3);
+				igt_debug("Dropping caches...\n");
+				igt_drop_caches_set(fd, DROP_ACTIVE);
+			}
+
+			close(fd);
+		}
+
+		/*
+		 * When memory pressure clients have managed to use up all
+		 * available RAM, let them run for a brief moment yet and then
+		 * manually trigger the OOM condition.
+		 */
+		for (unsigned long ram_mb = 0;
+		     (ram_mb = get_avail_ram_mb()) > 512;) {
+			int status;
+			pid_t pid;
+
+			igt_debug("[%u] %lu MiB free\n", count, ram_mb);
+
+			pid = waitpid(mem_child.pid, &status, WNOHANG);
+			if (pid)
+				break;
+
+			pid = waitpid(gem_child.pid, &status, WNOHANG);
+			if (pid)
+				break;
+
+			pid = waitpid(eb_child.pid, &status, WNOHANG);
+			igt_assert_eq(pid, 0);
+
+			pid = waitpid(drop_child.pid, &status, WNOHANG);
+			igt_assert_eq(pid, 0);
+
+			sleep(1);
+		}
+
+		igt_debug("Triggering OOM...\n");
+		trigger_oom();
+
+		sleep(1);
+
+		igt_try_stop_helper(&mem_child);
+		igt_try_stop_helper(&gem_child);
+		igt_stop_helper(&eb_child);
+		igt_stop_helper(&drop_child);
+	} while (count < passes);
+}
+
 igt_main
 {
 	const struct test {
@@ -432,6 +808,31 @@ igt_main
 	igt_subtest("reclaim")
 		reclaim(I915_EXEC_DEFAULT, 2);
 
+	igt_subtest_group {
+		struct {
+			const char *name;
+			unsigned int flags;
+			unsigned int passes;
+		} *p, passes[] = {
+			{ "reclaims-and-oom-basic", TEST_BO, 1 },
+			{ "reclaims-and-oom", TEST_BO, 3 },
+			{ "reclaims-and-oom-userptr-basic", TEST_USERPTR, 1 },
+			{ "reclaims-and-oom-userptr", TEST_USERPTR, 3 },
+			{ "reclaims-and-oom-both-basic", TEST_BO | TEST_USERPTR, 1 },
+			{ "reclaims-and-oom-both", TEST_BO | TEST_USERPTR, 3 },
+			{ NULL, 0, 0 },
+		};
+
+		igt_fixture {
+			igt_require(has_sysrq_trigger());
+		}
+
+		for (p = passes; p->name; p++) {
+			igt_subtest(p->name)
+				reclaim_oom(p->flags, p->passes);
+		}
+	}
+
 	for(const struct test *t = tests; t->name; t++) {
 		for(const struct mode *m = modes; m->suffix; m++) {
 			igt_subtest_f("%s%s", t->name, m->suffix)
diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
index 73d127603d28..b6e302db381e 100644
--- a/tests/intel-ci/blacklist.txt
+++ b/tests/intel-ci/blacklist.txt
@@ -59,7 +59,7 @@ igt@gem_ringfill@(?!.*basic).*
 igt@gem_ring_sync_copy(@.*)?
 igt@gem_ring_sync_loop(@.*)?
 igt@gem_seqno_wrap(@.*)?
-igt@gem_shrink@(?!reclaim$).*
+igt@gem_shrink@(?!reclaim).*
 igt@gem_softpin@.*(hang|S4).*
 igt@gem_spin_batch(@.*)?
 igt@gem_stolen@.*hibernate.*
diff --git a/tests/intel-ci/fast-feedback.testlist b/tests/intel-ci/fast-feedback.testlist
index 6d42792c67f7..0df7cc2fd9fd 100644
--- a/tests/intel-ci/fast-feedback.testlist
+++ b/tests/intel-ci/fast-feedback.testlist
@@ -124,6 +124,9 @@ igt@gem_ringfill@basic-default
 igt@gem_ringfill@basic-default-interruptible
 igt@gem_ringfill@basic-default-forked
 igt@gem_ringfill@basic-default-fd
+igt@gem_shrink@reclaims-and-oom-basic
+igt@gem_shrink@reclaims-and-oom-userptr-basic
+igt@gem_shrink@reclaims-and-oom-both-basic
 igt@gem_sync@basic-all
 igt@gem_sync@basic-each
 igt@gem_sync@basic-many-each
-- 
2.19.1

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

Re: [igt-dev] [Intel-gfx] [PATCH i-g-t v3] tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time

[Chris Wilson]

Quoting Tvrtko Ursulin (2019-01-07 18:22:44)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> A set of subtests which exercises different paths to our shrinker code
> (including the OOM killer) in predictable and reasonable time budget.
> 
> v2:
>  * Fix blacklist regexp. (Petri Latvala)
> 
> v3:
>  * Skip userptr test if not userptr support.
> 
> Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> ---
>  lib/igt_core.c                        |  19 ++
>  lib/igt_core.h                        |   1 +
>  tests/i915/gem_shrink.c               | 401 ++++++++++++++++++++++++++
>  tests/intel-ci/blacklist.txt          |   2 +-
>  tests/intel-ci/fast-feedback.testlist |   3 +
>  5 files changed, 425 insertions(+), 1 deletion(-)
> 
> diff --git a/lib/igt_core.c b/lib/igt_core.c
> index 50d6008f6c82..351da0b4e020 100644
> --- a/lib/igt_core.c
> +++ b/lib/igt_core.c
> @@ -1685,6 +1685,25 @@ void igt_stop_helper(struct igt_helper_process *proc)
>         assert(helper_was_alive(proc, status));
>  }
>  
> +/**
> + * igt_try_stop_helper:
> + * @proc: #igt_helper_process structure
> + *
> + * Terminates a helper process if it is still running and returns true, or false
> + * if the process wasn't running.
> + */
> +bool igt_try_stop_helper(struct igt_helper_process *proc)
> +{
> +       int status;
> +
> +       /* failure here means the pid is already dead and so waiting is safe */
> +       kill(proc->pid, proc->use_SIGKILL ? SIGKILL : SIGTERM);
> +
> +       status = igt_wait_helper(proc);
> +
> +       return helper_was_alive(proc, status);
> +}
> +
>  static void children_exit_handler(int sig)
>  {
>         int status;
> diff --git a/lib/igt_core.h b/lib/igt_core.h
> index 6f8c3852a686..ed5ceebf1205 100644
> --- a/lib/igt_core.h
> +++ b/lib/igt_core.h
> @@ -795,6 +795,7 @@ bool __igt_fork_helper(struct igt_helper_process *proc);
>         for (; __igt_fork_helper(proc); exit(0))
>  int igt_wait_helper(struct igt_helper_process *proc);
>  void igt_stop_helper(struct igt_helper_process *proc);
> +bool igt_try_stop_helper(struct igt_helper_process *proc);
>  
>  /* exit handler code */
>  
> diff --git a/tests/i915/gem_shrink.c b/tests/i915/gem_shrink.c
> index c8e05814ee70..3d48cbebc2f9 100644
> --- a/tests/i915/gem_shrink.c
> +++ b/tests/i915/gem_shrink.c
> @@ -26,6 +26,10 @@
>   *
>   * Exercise the shrinker by overallocating GEM objects
>   */
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <sys/wait.h>
> +#include <fcntl.h>
>  
>  #include "igt.h"
>  #include "igt_gt.h"
> @@ -366,6 +370,378 @@ static void reclaim(unsigned engine, int timeout)
>         close(fd);
>  }
>  
> +static unsigned long get_meminfo(const char *info, const char *tag)
> +{
> +       const char *str;
> +       unsigned long val;
> +
> +       str = strstr(info, tag);
> +       if (str && sscanf(str + strlen(tag), " %lu", &val) == 1)
> +               return val >> 10;
> +
> +       igt_warn("Unrecognised /proc/meminfo field: '%s'\n", tag);
> +       return 0;
> +}
> +
> +static unsigned long get_avail_ram_mb(void)
> +{
> +       int fd;
> +       int ret;
> +       char buf[4096];
> +       unsigned long ram;
> +
> +       fd = open("/proc/meminfo", O_RDONLY);
> +       igt_assert_fd(fd);
> +
> +       ret = read(fd, buf, sizeof(buf));
> +       igt_assert(ret >= 0);
> +
> +       close(fd);
> +
> +       ram = get_meminfo(buf, "MemAvailable:");
> +       ram += get_meminfo(buf, "Buffers:");
> +       ram += get_meminfo(buf, "Cached:");
> +       ram += get_meminfo(buf, "SwapCached:");
> +
> +       return ram;
> +}
> +
> +struct test {
> +#define TEST_BO                (1)
> +#define TEST_USERPTR   (2)
> +       unsigned int flags;
> +       int fd;
> +};
> +
> +static uint32_t __get_pages(int fd, unsigned long alloc)
> +{
> +       uint32_t handle = gem_create(fd, alloc);
> +
> +       gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);

Only needs DOMAIN_CPU for us to call get_pages() and then avoids
excessive clflushing on !llc. (mempressure path, so I'm not sure if you
want to argue about exercising the clflush paths against mempressure.
I'd hope gem_shrink already covers that elsewhere...)

> +       gem_madvise(fd, handle, I915_MADV_DONTNEED);
> +
> +       return handle;
> +}
> +/*
> + * Use a specific way of using up memory until we are below a certain threshold.
> + */
> +static void *mempressure(void *arg)
> +{
> +       const unsigned int free_threshold_mb = 256;
> +       struct test_obj *list = NULL;
> +       struct test *test = arg;
> +       const unsigned int sz_mb = 2;
> +       const unsigned int sz = sz_mb << 20;
> +       unsigned int n = 0, max = 0;
> +       unsigned int blocks;
> +
> +       for (;;) {
> +               unsigned long ram_mb = get_avail_ram_mb();

...

> +               /*
> +                * Allocate memory blocks and record the current working set
> +                * size.
> +                */
> +               if (test->flags & TEST_BO) {
> +                       list[n].handle = __get_pages(test->fd, sz);

Under discussion is that in using gem_create() our bo are accounted by
Cached: in /proc/meminfo. That is we never _appear_ to decrease
avail_ram_mb when for TEST_BO. One hack for drm-tip (since we now mark
shmemfs objects as unevictable) would be to use
	ram -= get_meminfo(buf, "Unevictable:");
-Chris
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev2)

[Patchwork]

== Series Details ==

Series: tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev2)
URL   : https://patchwork.freedesktop.org/series/54746/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_5369 -> IGTPW_2191
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_2191 absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_2191, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/54746/revisions/2/mbox/

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

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

### IGT changes ###

#### Possible regressions ####

  * igt@i915_selftest@live_gtt:
    - fi-kbl-r:           PASS -> DMESG-WARN

  
#### Suppressed ####

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

  * {igt@gem_shrink@reclaims-and-oom-both-basic}:
    - fi-ivb-3520m:       NOTRUN -> DMESG-WARN
    - fi-snb-2520m:       NOTRUN -> DMESG-WARN
    - fi-kbl-8809g:       NOTRUN -> DMESG-WARN
    - fi-glk-j4005:       NOTRUN -> DMESG-WARN
    - fi-cfl-8700k:       NOTRUN -> DMESG-WARN
    - fi-icl-u2:          NOTRUN -> DMESG-WARN
    - fi-kbl-7500u:       NOTRUN -> DMESG-WARN
    - fi-bdw-gvtdvm:      NOTRUN -> DMESG-WARN
    - fi-kbl-x1275:       NOTRUN -> DMESG-WARN
    - fi-kbl-guc:         NOTRUN -> DMESG-WARN
    - fi-kbl-7567u:       NOTRUN -> DMESG-WARN
    - fi-icl-u3:          NOTRUN -> DMESG-WARN
    - fi-skl-guc:         NOTRUN -> DMESG-WARN
    - fi-bxt-j4205:       NOTRUN -> DMESG-WARN
    - fi-skl-6700hq:      NOTRUN -> DMESG-WARN
    - fi-bsw-kefka:       NOTRUN -> DMESG-WARN
    - fi-ivb-3770:        NOTRUN -> DMESG-WARN
    - fi-skl-6700k2:      NOTRUN -> DMESG-WARN
    - fi-hsw-4770:        NOTRUN -> DMESG-WARN
    - fi-kbl-7560u:       NOTRUN -> DMESG-WARN
    - fi-skl-6600u:       NOTRUN -> DMESG-WARN
    - fi-apl-guc:         NOTRUN -> DMESG-WARN
    - fi-kbl-r:           NOTRUN -> DMESG-WARN
    - fi-byt-j1900:       NOTRUN -> DMESG-WARN
    - fi-blb-e6850:       NOTRUN -> DMESG-WARN
    - fi-cfl-8109u:       NOTRUN -> DMESG-WARN
    - fi-bdw-5557u:       NOTRUN -> DMESG-WARN
    - fi-elk-e7500:       NOTRUN -> DMESG-WARN
    - fi-hsw-4770r:       NOTRUN -> DMESG-WARN
    - fi-byt-n2820:       NOTRUN -> DMESG-WARN
    - fi-skl-6260u:       NOTRUN -> DMESG-WARN
    - fi-skl-iommu:       NOTRUN -> DMESG-WARN
    - fi-ilk-650:         NOTRUN -> DMESG-WARN
    - fi-skl-6770hq:      NOTRUN -> DMESG-WARN
    - fi-whl-u:           NOTRUN -> DMESG-WARN
    - fi-cfl-guc:         NOTRUN -> DMESG-WARN

  * {igt@gem_shrink@reclaims-and-oom-userptr-basic}:
    - fi-bwr-2160:        NOTRUN -> FAIL +1

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

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

### IGT changes ###

#### Issues hit ####

  * igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a-frame-sequence:
    - fi-byt-clapper:     PASS -> FAIL [fdo#103191] / [fdo#107362]

  * igt@prime_vgem@basic-fence-flip:
    - fi-gdg-551:         PASS -> FAIL [fdo#103182]

  
#### Possible fixes ####

  * igt@gem_mmap_gtt@basic-small-copy:
    - fi-glk-dsi:         INCOMPLETE [fdo#103359] / [k.org#198133] -> PASS

  * igt@i915_selftest@live_coherency:
    - fi-gdg-551:         DMESG-FAIL [fdo#107164] -> PASS

  * igt@i915_selftest@live_hangcheck:
    - fi-bwr-2160:        DMESG-FAIL [fdo#108735] -> PASS

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

  [fdo#103182]: https://bugs.freedesktop.org/show_bug.cgi?id=103182
  [fdo#103191]: https://bugs.freedesktop.org/show_bug.cgi?id=103191
  [fdo#103359]: https://bugs.freedesktop.org/show_bug.cgi?id=103359
  [fdo#104108]: https://bugs.freedesktop.org/show_bug.cgi?id=104108
  [fdo#107164]: https://bugs.freedesktop.org/show_bug.cgi?id=107164
  [fdo#107362]: https://bugs.freedesktop.org/show_bug.cgi?id=107362
  [fdo#108735]: https://bugs.freedesktop.org/show_bug.cgi?id=108735
  [fdo#109241]: https://bugs.freedesktop.org/show_bug.cgi?id=109241
  [k.org#198133]: https://bugzilla.kernel.org/show_bug.cgi?id=198133


Participating hosts (49 -> 44)
------------------------------

  Additional (1): fi-pnv-d510 
  Missing    (6): fi-kbl-soraka fi-ilk-m540 fi-byt-squawks fi-bsw-cyan fi-icl-y fi-snb-2600 


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

    * IGT: IGT_4756 -> IGTPW_2191

  CI_DRM_5369: 4d637a8d160356f01d22695ec1a76858bfb55758 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_2191: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2191/
  IGT_4756: 75081c6bfb9998bd7cbf35a7ac0578c683fe55a8 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools



== Testlist changes ==

+igt@gem_shrink@reclaims-and-oom
+igt@gem_shrink@reclaims-and-oom-basic
+igt@gem_shrink@reclaims-and-oom-both
+igt@gem_shrink@reclaims-and-oom-both-basic
+igt@gem_shrink@reclaims-and-oom-userptr
+igt@gem_shrink@reclaims-and-oom-userptr-basic

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2191/
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev2)

[Tvrtko Ursulin]

On 07/01/2019 18:00, Patchwork wrote:
> == Series Details ==
> 
> Series: tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev2)
> URL   : https://patchwork.freedesktop.org/series/54746/
> State : failure
> 
> == Summary ==
> 
> CI Bug Log - changes from CI_DRM_5369 -> IGTPW_2191
> ====================================================
> 
> Summary
> -------
> 
>    **FAILURE**
> 
>    Serious unknown changes coming with IGTPW_2191 absolutely need to be
>    verified manually.
>    
>    If you think the reported changes have nothing to do with the changes
>    introduced in IGTPW_2191, please notify your bug team to allow them
>    to document this new failure mode, which will reduce false positives in CI.
> 
>    External URL: https://patchwork.freedesktop.org/api/1.0/series/54746/revisions/2/mbox/
> 
> Possible new issues
> -------------------
> 
>    Here are the unknown changes that may have been introduced in IGTPW_2191:
> 
> ### IGT changes ###
> 
> #### Possible regressions ####
> 
>    * igt@i915_selftest@live_gtt:
>      - fi-kbl-r:           PASS -> DMESG-WARN

No idea what we are looking at here!? :)

> 
>    
> #### Suppressed ####
> 
>    The following results come from untrusted machines, tests, or statuses.
>    They do not affect the overall result.
> 
>    * {igt@gem_shrink@reclaims-and-oom-both-basic}:
>      - fi-ivb-3520m:       NOTRUN -> DMESG-WARN
>      - fi-snb-2520m:       NOTRUN -> DMESG-WARN
>      - fi-kbl-8809g:       NOTRUN -> DMESG-WARN
>      - fi-glk-j4005:       NOTRUN -> DMESG-WARN
>      - fi-cfl-8700k:       NOTRUN -> DMESG-WARN
>      - fi-icl-u2:          NOTRUN -> DMESG-WARN
>      - fi-kbl-7500u:       NOTRUN -> DMESG-WARN
>      - fi-bdw-gvtdvm:      NOTRUN -> DMESG-WARN
>      - fi-kbl-x1275:       NOTRUN -> DMESG-WARN
>      - fi-kbl-guc:         NOTRUN -> DMESG-WARN
>      - fi-kbl-7567u:       NOTRUN -> DMESG-WARN
>      - fi-icl-u3:          NOTRUN -> DMESG-WARN
>      - fi-skl-guc:         NOTRUN -> DMESG-WARN
>      - fi-bxt-j4205:       NOTRUN -> DMESG-WARN
>      - fi-skl-6700hq:      NOTRUN -> DMESG-WARN
>      - fi-bsw-kefka:       NOTRUN -> DMESG-WARN
>      - fi-ivb-3770:        NOTRUN -> DMESG-WARN
>      - fi-skl-6700k2:      NOTRUN -> DMESG-WARN
>      - fi-hsw-4770:        NOTRUN -> DMESG-WARN
>      - fi-kbl-7560u:       NOTRUN -> DMESG-WARN
>      - fi-skl-6600u:       NOTRUN -> DMESG-WARN
>      - fi-apl-guc:         NOTRUN -> DMESG-WARN
>      - fi-kbl-r:           NOTRUN -> DMESG-WARN
>      - fi-byt-j1900:       NOTRUN -> DMESG-WARN
>      - fi-blb-e6850:       NOTRUN -> DMESG-WARN
>      - fi-cfl-8109u:       NOTRUN -> DMESG-WARN
>      - fi-bdw-5557u:       NOTRUN -> DMESG-WARN
>      - fi-elk-e7500:       NOTRUN -> DMESG-WARN
>      - fi-hsw-4770r:       NOTRUN -> DMESG-WARN
>      - fi-byt-n2820:       NOTRUN -> DMESG-WARN
>      - fi-skl-6260u:       NOTRUN -> DMESG-WARN
>      - fi-skl-iommu:       NOTRUN -> DMESG-WARN
>      - fi-ilk-650:         NOTRUN -> DMESG-WARN
>      - fi-skl-6770hq:      NOTRUN -> DMESG-WARN
>      - fi-whl-u:           NOTRUN -> DMESG-WARN
>      - fi-cfl-guc:         NOTRUN -> DMESG-WARN

Yay, test found something! :)

> 
>    * {igt@gem_shrink@reclaims-and-oom-userptr-basic}:
>      - fi-bwr-2160:        NOTRUN -> FAIL +1

Fixed in v3.

Regards,

Tvrtko

>    
> Known issues
> ------------
> 
>    Here are the changes found in IGTPW_2191 that come from known issues:
> 
> ### IGT changes ###
> 
> #### Issues hit ####
> 
>    * igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a-frame-sequence:
>      - fi-byt-clapper:     PASS -> FAIL [fdo#103191] / [fdo#107362]
> 
>    * igt@prime_vgem@basic-fence-flip:
>      - fi-gdg-551:         PASS -> FAIL [fdo#103182]
> 
>    
> #### Possible fixes ####
> 
>    * igt@gem_mmap_gtt@basic-small-copy:
>      - fi-glk-dsi:         INCOMPLETE [fdo#103359] / [k.org#198133] -> PASS
> 
>    * igt@i915_selftest@live_coherency:
>      - fi-gdg-551:         DMESG-FAIL [fdo#107164] -> PASS
> 
>    * igt@i915_selftest@live_hangcheck:
>      - fi-bwr-2160:        DMESG-FAIL [fdo#108735] -> PASS
> 
>    
>    {name}: This element is suppressed. This means it is ignored when computing
>            the status of the difference (SUCCESS, WARNING, or FAILURE).
> 
>    [fdo#103182]: https://bugs.freedesktop.org/show_bug.cgi?id=103182
>    [fdo#103191]: https://bugs.freedesktop.org/show_bug.cgi?id=103191
>    [fdo#103359]: https://bugs.freedesktop.org/show_bug.cgi?id=103359
>    [fdo#104108]: https://bugs.freedesktop.org/show_bug.cgi?id=104108
>    [fdo#107164]: https://bugs.freedesktop.org/show_bug.cgi?id=107164
>    [fdo#107362]: https://bugs.freedesktop.org/show_bug.cgi?id=107362
>    [fdo#108735]: https://bugs.freedesktop.org/show_bug.cgi?id=108735
>    [fdo#109241]: https://bugs.freedesktop.org/show_bug.cgi?id=109241
>    [k.org#198133]: https://bugzilla.kernel.org/show_bug.cgi?id=198133
> 
> 
> Participating hosts (49 -> 44)
> ------------------------------
> 
>    Additional (1): fi-pnv-d510
>    Missing    (6): fi-kbl-soraka fi-ilk-m540 fi-byt-squawks fi-bsw-cyan fi-icl-y fi-snb-2600
> 
> 
> Build changes
> -------------
> 
>      * IGT: IGT_4756 -> IGTPW_2191
> 
>    CI_DRM_5369: 4d637a8d160356f01d22695ec1a76858bfb55758 @ git://anongit.freedesktop.org/gfx-ci/linux
>    IGTPW_2191: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2191/
>    IGT_4756: 75081c6bfb9998bd7cbf35a7ac0578c683fe55a8 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
> 
> 
> 
> == Testlist changes ==
> 
> +igt@gem_shrink@reclaims-and-oom
> +igt@gem_shrink@reclaims-and-oom-basic
> +igt@gem_shrink@reclaims-and-oom-both
> +igt@gem_shrink@reclaims-and-oom-both-basic
> +igt@gem_shrink@reclaims-and-oom-userptr
> +igt@gem_shrink@reclaims-and-oom-userptr-basic
> 
> == Logs ==
> 
> For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2191/
> 
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Re: [igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev2)

[Chris Wilson]

Quoting Tvrtko Ursulin (2019-01-07 18:25:34)
> 
> On 07/01/2019 18:00, Patchwork wrote:
> > 
> >    * {igt@gem_shrink@reclaims-and-oom-both-basic}:
> >      - fi-ivb-3520m:       NOTRUN -> DMESG-WARN
> 
> Yay, test found something! :)

Test requirement not met in function __real_main745, file ../tests/i915/gem_shrink.c:827:
Test requirement: has_sysrq_trigger()

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

Re: [igt-dev] ✗ Fi.CI.BAT: failure for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev2)

[Chris Wilson]

Quoting Chris Wilson (2019-01-07 20:53:48)
> Quoting Tvrtko Ursulin (2019-01-07 18:25:34)
> > 
> > On 07/01/2019 18:00, Patchwork wrote:
> > > 
> > >    * {igt@gem_shrink@reclaims-and-oom-both-basic}:
> > >      - fi-ivb-3520m:       NOTRUN -> DMESG-WARN
> > 
> > Yay, test found something! :)
> 
> Test requirement not met in function __real_main745, file ../tests/i915/gem_shrink.c:827:
> Test requirement: has_sysrq_trigger()

Fwiw, with whatever changed in 5.0, the oom_trigger is not required for
the lockdep warning.

(I'm not sure if the oom_trigger adds anything useful; the nasty oom
conditions will be from inside page_alloc after direct reclaim fails.
Indeed, I don't think oom itself does anything that would trigger the
mmu_notifier? Do you know of a path?)
-Chris
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.BAT: success for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev3)

[Patchwork]

== Series Details ==

Series: tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev3)
URL   : https://patchwork.freedesktop.org/series/54746/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_5369 -> IGTPW_2192
====================================================

Summary
-------

  **WARNING**

  Minor unknown changes coming with IGTPW_2192 need to be verified
  manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_2192, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/54746/revisions/3/mbox/

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

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

### IGT changes ###

#### Warnings ####

  * igt@pm_rpm@basic-pci-d3-state:
    - fi-bsw-kefka:       PASS -> SKIP

  
#### Suppressed ####

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

  * {igt@gem_shrink@reclaims-and-oom-both-basic}:
    - fi-ivb-3520m:       NOTRUN -> DMESG-WARN
    - fi-snb-2520m:       NOTRUN -> DMESG-WARN
    - fi-kbl-8809g:       NOTRUN -> DMESG-WARN
    - fi-glk-j4005:       NOTRUN -> DMESG-WARN
    - fi-cfl-8700k:       NOTRUN -> DMESG-WARN
    - fi-icl-u2:          NOTRUN -> DMESG-WARN
    - fi-kbl-7500u:       NOTRUN -> DMESG-WARN
    - fi-bdw-gvtdvm:      NOTRUN -> DMESG-WARN
    - fi-kbl-x1275:       NOTRUN -> DMESG-WARN
    - fi-kbl-guc:         NOTRUN -> DMESG-WARN
    - fi-kbl-7567u:       NOTRUN -> DMESG-WARN
    - fi-icl-u3:          NOTRUN -> DMESG-WARN
    - fi-skl-guc:         NOTRUN -> DMESG-WARN
    - fi-glk-dsi:         NOTRUN -> DMESG-WARN
    - fi-bxt-j4205:       NOTRUN -> DMESG-WARN
    - fi-skl-6700hq:      NOTRUN -> DMESG-WARN
    - fi-bsw-kefka:       NOTRUN -> DMESG-WARN
    - fi-ivb-3770:        NOTRUN -> DMESG-WARN
    - fi-skl-6700k2:      NOTRUN -> DMESG-WARN
    - fi-bsw-n3050:       NOTRUN -> DMESG-WARN
    - fi-hsw-4770:        NOTRUN -> DMESG-WARN
    - fi-kbl-7560u:       NOTRUN -> DMESG-WARN
    - fi-skl-6600u:       NOTRUN -> DMESG-WARN
    - fi-apl-guc:         NOTRUN -> DMESG-WARN
    - fi-kbl-r:           NOTRUN -> DMESG-WARN
    - fi-byt-j1900:       NOTRUN -> DMESG-WARN
    - fi-cfl-8109u:       NOTRUN -> DMESG-WARN
    - fi-bdw-5557u:       NOTRUN -> DMESG-WARN
    - fi-elk-e7500:       NOTRUN -> DMESG-WARN
    - fi-hsw-4770r:       NOTRUN -> DMESG-WARN
    - fi-byt-n2820:       NOTRUN -> DMESG-WARN
    - fi-skl-6260u:       NOTRUN -> DMESG-WARN
    - fi-skl-iommu:       NOTRUN -> DMESG-WARN
    - fi-ilk-650:         NOTRUN -> DMESG-WARN
    - fi-skl-6770hq:      NOTRUN -> DMESG-WARN
    - fi-whl-u:           NOTRUN -> DMESG-WARN
    - fi-cfl-guc:         NOTRUN -> DMESG-WARN

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

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

### IGT changes ###

#### Issues hit ####

  * igt@kms_pipe_crc_basic@nonblocking-crc-pipe-b-frame-sequence:
    - fi-byt-clapper:     PASS -> FAIL [fdo#103191] / [fdo#107362]

  * igt@pm_rpm@basic-rte:
    - fi-bsw-kefka:       PASS -> FAIL [fdo#108800]

  
#### Possible fixes ####

  * igt@gem_mmap_gtt@basic-small-copy:
    - fi-glk-dsi:         INCOMPLETE [fdo#103359] / [k.org#198133] -> PASS

  * igt@i915_selftest@live_coherency:
    - fi-gdg-551:         DMESG-FAIL [fdo#107164] -> PASS

  * igt@i915_selftest@live_hangcheck:
    - fi-bwr-2160:        DMESG-FAIL [fdo#108735] -> PASS

  * igt@kms_pipe_crc_basic@suspend-read-crc-pipe-b:
    - fi-blb-e6850:       INCOMPLETE [fdo#107718] -> PASS

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

  [fdo#103191]: https://bugs.freedesktop.org/show_bug.cgi?id=103191
  [fdo#103359]: https://bugs.freedesktop.org/show_bug.cgi?id=103359
  [fdo#104108]: https://bugs.freedesktop.org/show_bug.cgi?id=104108
  [fdo#107164]: https://bugs.freedesktop.org/show_bug.cgi?id=107164
  [fdo#107362]: https://bugs.freedesktop.org/show_bug.cgi?id=107362
  [fdo#107718]: https://bugs.freedesktop.org/show_bug.cgi?id=107718
  [fdo#108735]: https://bugs.freedesktop.org/show_bug.cgi?id=108735
  [fdo#108800]: https://bugs.freedesktop.org/show_bug.cgi?id=108800
  [fdo#109241]: https://bugs.freedesktop.org/show_bug.cgi?id=109241
  [k.org#198133]: https://bugzilla.kernel.org/show_bug.cgi?id=198133


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

  Additional (1): fi-pnv-d510 
  Missing    (5): fi-kbl-soraka fi-ilk-m540 fi-byt-squawks fi-bsw-cyan fi-icl-y 


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

    * IGT: IGT_4756 -> IGTPW_2192

  CI_DRM_5369: 4d637a8d160356f01d22695ec1a76858bfb55758 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_2192: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2192/
  IGT_4756: 75081c6bfb9998bd7cbf35a7ac0578c683fe55a8 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools



== Testlist changes ==

+igt@gem_shrink@reclaims-and-oom
+igt@gem_shrink@reclaims-and-oom-basic
+igt@gem_shrink@reclaims-and-oom-both
+igt@gem_shrink@reclaims-and-oom-both-basic
+igt@gem_shrink@reclaims-and-oom-userptr
+igt@gem_shrink@reclaims-and-oom-userptr-basic

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2192/
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

[igt-dev] ✓ Fi.CI.IGT: success for tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev3)

[Patchwork]

== Series Details ==

Series: tests/gem_shrink: Exercise OOM and other routes to shrinking in reasonable time (rev3)
URL   : https://patchwork.freedesktop.org/series/54746/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_5369_full -> IGTPW_2192_full
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://patchwork.freedesktop.org/api/1.0/series/54746/revisions/3/mbox/

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

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

### IGT changes ###

#### Suppressed ####

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

  * {igt@gem_shrink@reclaims-and-oom-both}:
    - shard-hsw:          NOTRUN -> DMESG-WARN +2
    - shard-snb:          NOTRUN -> DMESG-WARN

  * {igt@gem_shrink@reclaims-and-oom-both-basic}:
    - shard-kbl:          NOTRUN -> DMESG-WARN
    - shard-apl:          NOTRUN -> DMESG-WARN +1
    - shard-glk:          NOTRUN -> DMESG-WARN +1

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

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

### IGT changes ###

#### Issues hit ####

  * igt@kms_busy@extended-modeset-hang-newfb-with-reset-render-a:
    - shard-snb:          NOTRUN -> DMESG-WARN [fdo#107956]

  * igt@kms_cursor_crc@cursor-128x128-onscreen:
    - shard-kbl:          PASS -> FAIL [fdo#103232] +1
    - shard-glk:          PASS -> FAIL [fdo#103232]

  * igt@kms_cursor_crc@cursor-128x128-suspend:
    - shard-apl:          PASS -> FAIL [fdo#103191] / [fdo#103232]

  * igt@kms_cursor_crc@cursor-64x21-random:
    - shard-apl:          PASS -> FAIL [fdo#103232] +4

  * igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic:
    - shard-hsw:          PASS -> FAIL [fdo#105767]

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-gtt:
    - shard-apl:          PASS -> FAIL [fdo#103167] +2

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-draw-mmap-gtt:
    - shard-glk:          PASS -> FAIL [fdo#103167] +1

  * igt@kms_plane@plane-position-covered-pipe-c-planes:
    - shard-apl:          PASS -> FAIL [fdo#103166] +1

  * igt@kms_plane_alpha_blend@pipe-c-alpha-opaque-fb:
    - shard-glk:          PASS -> FAIL [fdo#108145]

  * igt@kms_plane_multiple@atomic-pipe-a-tiling-y:
    - shard-kbl:          PASS -> FAIL [fdo#103166] +2

  * igt@kms_plane_multiple@atomic-pipe-b-tiling-y:
    - shard-glk:          PASS -> FAIL [fdo#103166] +3

  * igt@kms_setmode@basic:
    - shard-hsw:          PASS -> FAIL [fdo#99912]
    - shard-snb:          NOTRUN -> FAIL [fdo#99912]

  
#### Possible fixes ####

  * igt@gem_exec_suspend@basic-s4-devices:
    - shard-kbl:          DMESG-WARN [fdo#103558] / [fdo#105602] / [fdo#107139] -> PASS

  * igt@kms_cursor_crc@cursor-128x42-onscreen:
    - shard-glk:          FAIL [fdo#103232] -> PASS +2

  * igt@kms_cursor_crc@cursor-256x85-onscreen:
    - shard-apl:          FAIL [fdo#103232] -> PASS +3

  * igt@kms_cursor_crc@cursor-64x64-suspend:
    - shard-apl:          FAIL [fdo#103191] / [fdo#103232] -> PASS

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-pwrite:
    - shard-apl:          FAIL [fdo#103167] -> PASS +1

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-draw-mmap-cpu:
    - shard-glk:          FAIL [fdo#103167] -> PASS +5

  * igt@kms_plane@plane-position-covered-pipe-b-planes:
    - shard-glk:          FAIL [fdo#103166] -> PASS +4

  * igt@kms_plane_alpha_blend@pipe-a-constant-alpha-max:
    - shard-glk:          FAIL [fdo#108145] -> PASS +1

  * igt@kms_plane_multiple@atomic-pipe-c-tiling-yf:
    - shard-apl:          FAIL [fdo#103166] -> PASS +3
    - shard-kbl:          FAIL [fdo#103166] -> PASS +1

  * igt@kms_rotation_crc@multiplane-rotation-cropping-top:
    - shard-glk:          DMESG-FAIL [fdo#105763] / [fdo#106538] -> PASS

  * igt@kms_setmode@basic:
    - shard-kbl:          FAIL [fdo#99912] -> PASS

  * igt@kms_vblank@pipe-a-ts-continuation-dpms-suspend:
    - shard-kbl:          INCOMPLETE [fdo#103665] -> PASS

  * igt@kms_vblank@pipe-c-ts-continuation-modeset-rpm:
    - shard-kbl:          DMESG-WARN [fdo#103558] / [fdo#105602] -> PASS +2

  * igt@perf@rc6-disable:
    - shard-kbl:          FAIL [fdo#103179] -> PASS

  * igt@pm_rps@min-max-config-loaded:
    - shard-glk:          FAIL [fdo#102250] -> PASS

  * igt@prime_vgem@basic-fence-flip:
    - shard-apl:          FAIL [fdo#104008] -> PASS

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

  [fdo#102250]: https://bugs.freedesktop.org/show_bug.cgi?id=102250
  [fdo#103166]: https://bugs.freedesktop.org/show_bug.cgi?id=103166
  [fdo#103167]: https://bugs.freedesktop.org/show_bug.cgi?id=103167
  [fdo#103179]: https://bugs.freedesktop.org/show_bug.cgi?id=103179
  [fdo#103191]: https://bugs.freedesktop.org/show_bug.cgi?id=103191
  [fdo#103232]: https://bugs.freedesktop.org/show_bug.cgi?id=103232
  [fdo#103558]: https://bugs.freedesktop.org/show_bug.cgi?id=103558
  [fdo#103665]: https://bugs.freedesktop.org/show_bug.cgi?id=103665
  [fdo#104008]: https://bugs.freedesktop.org/show_bug.cgi?id=104008
  [fdo#105602]: https://bugs.freedesktop.org/show_bug.cgi?id=105602
  [fdo#105763]: https://bugs.freedesktop.org/show_bug.cgi?id=105763
  [fdo#105767]: https://bugs.freedesktop.org/show_bug.cgi?id=105767
  [fdo#106538]: https://bugs.freedesktop.org/show_bug.cgi?id=106538
  [fdo#107139]: https://bugs.freedesktop.org/show_bug.cgi?id=107139
  [fdo#107469]: https://bugs.freedesktop.org/show_bug.cgi?id=107469
  [fdo#107956]: https://bugs.freedesktop.org/show_bug.cgi?id=107956
  [fdo#108145]: https://bugs.freedesktop.org/show_bug.cgi?id=108145
  [fdo#108784]: https://bugs.freedesktop.org/show_bug.cgi?id=108784
  [fdo#109241]: https://bugs.freedesktop.org/show_bug.cgi?id=109241
  [fdo#99912]: https://bugs.freedesktop.org/show_bug.cgi?id=99912


Participating hosts (7 -> 5)
------------------------------

  Missing    (2): shard-skl shard-iclb 


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

    * IGT: IGT_4756 -> IGTPW_2192
    * Piglit: piglit_4509 -> None

  CI_DRM_5369: 4d637a8d160356f01d22695ec1a76858bfb55758 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_2192: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2192/
  IGT_4756: 75081c6bfb9998bd7cbf35a7ac0578c683fe55a8 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
  piglit_4509: fdc5a4ca11124ab8413c7988896eec4c97336694 @ git://anongit.freedesktop.org/piglit

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_2192/
_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev