Exercise O(N^2) behaviour in reading the error state, and push it to the
extreme.
Reported-by: Jason Ekstrand <ja...@jlekstrand.net>
Signed-off-by: Chris Wilson <ch...@chris-wilson.co.uk>
---
lib/meson.build | 1 +
tests/gem_exec_capture.c | 320 ++++++++++++++++++++++++++++++++++-
tests/intel-ci/blacklist.txt | 1 +
3 files changed, 319 insertions(+), 3 deletions(-)
diff --git a/lib/meson.build b/lib/meson.build
index e60e5e02f..ce5465b63 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -66,6 +66,7 @@ lib_deps = [
math,
realtime,
ssl,
+ zlib
]
if libdrm_intel.found()
diff --git a/tests/gem_exec_capture.c b/tests/gem_exec_capture.c
index 2dc06ce43..2d0839468 100644
--- a/tests/gem_exec_capture.c
+++ b/tests/gem_exec_capture.c
@@ -21,8 +21,11 @@
* IN THE SOFTWARE.
*/
+#include <zlib.h>
+
#include "igt.h"
#include "igt_device.h"
+#include "igt_rand.h"
#include "igt_sysfs.h"
#define LOCAL_OBJECT_CAPTURE (1 << 7)
@@ -54,10 +57,11 @@ static void check_error_state(int dir, struct
drm_i915_gem_exec_object2 *obj)
found = true;
}
+ free(error);
igt_assert(found);
}
-static void __capture(int fd, int dir, unsigned ring, uint32_t target)
+static void __capture1(int fd, int dir, unsigned ring, uint32_t target)
{
const int gen = intel_gen(intel_get_drm_devid(fd));
struct drm_i915_gem_exec_object2 obj[4];
@@ -167,10 +171,295 @@ static void capture(int fd, int dir, unsigned ring)
uint32_t handle;
handle = gem_create(fd, 4096);
- __capture(fd, dir, ring, handle);
+ __capture1(fd, dir, ring, handle);
gem_close(fd, handle);
}
+static uint64_t *__captureN(int fd, int dir, unsigned ring,
+ unsigned int size, int count,
+ unsigned int flags)
+#define INCREMENTAL 0x1
+{
+ const int gen = intel_gen(intel_get_drm_devid(fd));
+ struct drm_i915_gem_exec_object2 *obj;
+ struct drm_i915_gem_relocation_entry reloc[2];
+ struct drm_i915_gem_execbuffer2 execbuf;
+ uint32_t *batch, *seqno;
+ uint64_t *offsets;
+ int i;
+
+ offsets = calloc(count , sizeof(*offsets));
+ igt_assert(offsets);
+
+ obj = calloc(count + 2, sizeof(*obj));
+ igt_assert(obj);
+
+ obj[0].handle = gem_create(fd, 4096);
+ for (i = 0; i < count; i++) {
+ obj[i + 1].handle = gem_create(fd, size);
+ obj[i + 1].flags =
+ LOCAL_OBJECT_CAPTURE | EXEC_OBJECT_SUPPORTS_48B_ADDRESS;
+ if (flags & INCREMENTAL) {
+ uint32_t *ptr;
+
+ ptr = gem_mmap__cpu(fd, obj[i + 1].handle,
+ 0, size, PROT_WRITE);
+ for (unsigned int n = 0; n < size / sizeof(*ptr); n++)
+ ptr[n] = i * size + n;
+ munmap(ptr, size);
+ }
+ }
+
+ obj[count + 1].handle = gem_create(fd, 4096);
+ obj[count + 1].relocs_ptr = (uintptr_t)reloc;
+ obj[count + 1].relocation_count = ARRAY_SIZE(reloc);
+
+ memset(reloc, 0, sizeof(reloc));
+ reloc[0].target_handle = obj[count + 1].handle; /* recurse */
+ reloc[0].presumed_offset = 0;
+ reloc[0].offset = 5*sizeof(uint32_t);
+ reloc[0].delta = 0;
+ reloc[0].read_domains = I915_GEM_DOMAIN_COMMAND;
+ reloc[0].write_domain = 0;
+
+ reloc[1].target_handle = obj[0].handle; /* breadcrumb */
+ reloc[1].presumed_offset = 0;
+ reloc[1].offset = sizeof(uint32_t);
+ reloc[1].delta = 0;
+ reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;
+ reloc[1].write_domain = I915_GEM_DOMAIN_RENDER;
+
+ seqno = gem_mmap__wc(fd, obj[0].handle, 0, 4096, PROT_READ);
+ gem_set_domain(fd, obj[0].handle,
+ I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
+
+ batch = gem_mmap__cpu(fd, obj[count + 1].handle, 0, 4096, PROT_WRITE);
+ gem_set_domain(fd, obj[count + 1].handle,
+ I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
+
+ i = 0;
+ batch[i] = MI_STORE_DWORD_IMM | (gen < 6 ? 1 << 22 : 0);
+ if (gen >= 8) {
+ batch[++i] = 0;
+ batch[++i] = 0;
+ } else if (gen >= 4) {
+ batch[++i] = 0;
+ batch[++i] = 0;
+ reloc[1].offset += sizeof(uint32_t);
+ } else {
+ batch[i]--;
+ batch[++i] = 0;
+ }
+ batch[++i] = 0xc0ffee;
+ if (gen < 3)
+ batch[++i] = MI_NOOP;
+
+ batch[++i] = MI_BATCH_BUFFER_START; /* not crashed? try again! */
+ if (gen >= 8) {
+ batch[i] |= 1 << 8 | 1;
+ batch[++i] = 0;
+ batch[++i] = 0;
+ } else if (gen >= 6) {
+ batch[i] |= 1 << 8;
+ batch[++i] = 0;
+ } else {
+ batch[i] |= 2 << 6;
+ batch[++i] = 0;
+ if (gen < 4) {
+ batch[i] |= 1;
+ reloc[0].delta = 1;
+ }
+ }
+ munmap(batch, 4096);
+
+ memset(&execbuf, 0, sizeof(execbuf));
+ execbuf.buffers_ptr = (uintptr_t)obj;
+ execbuf.buffer_count = count + 2;
+ execbuf.flags = ring;
+ if (gen > 3 && gen < 6)
+ execbuf.flags |= I915_EXEC_SECURE;
+ gem_execbuf(fd, &execbuf);
+
+ /* Wait for the request to start */
+ while (*(volatile uint32_t *)seqno != 0xc0ffee)
+ igt_assert(gem_bo_busy(fd, obj[0].handle));
+ munmap(seqno, 4096);
+
+ igt_force_gpu_reset(fd);
+
+ gem_sync(fd, obj[count + 1].handle);
+ gem_close(fd, obj[count + 1].handle);
+ for (i = 0; i < count; i++) {
+ offsets[i] = obj[i + 1].offset;
+ gem_close(fd, obj[i + 1].handle);
+ }
+ gem_close(fd, obj[0].handle);
+
+ return offsets;
+}
+
+static unsigned long zlib_inflate(uint32_t **ptr, unsigned long len)
+{
+ struct z_stream_s zstream;
+ void *out;
+
+ memset(&zstream, 0, sizeof(zstream));
+
+ zstream.next_in = (unsigned char *)*ptr;
+ zstream.avail_in = 4*len;
+
+ if (inflateInit(&zstream) != Z_OK)
+ return 0;
+
+ out = malloc(128*4096); /* approximate obj size */
+ zstream.next_out = out;
+ zstream.avail_out = 128*4096;
+
+ do {
+ switch (inflate(&zstream, Z_SYNC_FLUSH)) {
+ case Z_STREAM_END:
+ goto end;
+ case Z_OK:
+ break;
+ default:
+ inflateEnd(&zstream);
+ return 0;
+ }
+
+ if (zstream.avail_out)
+ break;
+
+ out = realloc(out, 2*zstream.total_out);
+ if (out == NULL) {
+ inflateEnd(&zstream);
+ return 0;
+ }
+
+ zstream.next_out = (unsigned char *)out + zstream.total_out;
+ zstream.avail_out = zstream.total_out;
+ } while (1);
+end:
+ inflateEnd(&zstream);
+ free(*ptr);
+ *ptr = out;
+ return zstream.total_out / 4;
+}
+
+static unsigned long
+ascii85_decode(const char *in, uint32_t **out, bool inflate)
+{
+ unsigned long len = 0, size = 1024;
+
+ *out = realloc(*out, sizeof(uint32_t)*size);
+ if (*out == NULL)
+ return 0;
+
+ while (*in >= '!' && *in <= 'z') {
+ uint32_t v = 0;
+
+ if (len == size) {
+ size *= 2;
+ *out = realloc(*out, sizeof(uint32_t)*size);
+ if (*out == NULL)
+ return 0;
+ }
+
+ if (*in == 'z') {
+ in++;
+ } else {
+ v += in[0] - 33; v *= 85;
+ v += in[1] - 33; v *= 85;
+ v += in[2] - 33; v *= 85;
+ v += in[3] - 33; v *= 85;
+ v += in[4] - 33;
+ in += 5;
+ }
+ (*out)[len++] = v;
+ }
+
+ if (!inflate)
+ return len;
+
+ return zlib_inflate(out, len);
+}
+
+static void many(int fd, int dir, uint64_t size, unsigned int flags)
+{
+ uint64_t ram, gtt;
+ unsigned long count, blobs;
+ char *error, *str;
+ uint64_t *offsets;
+
+ gtt = gem_aperture_size(fd) / size;
+ ram = (intel_get_avail_ram_mb() << 20) / size;
+ igt_debug("Available objects in GTT:%"PRIu64", RAM:%"PRIu64"\n",
+ gtt, ram);
+
+ count = min(gtt, ram) / 4;
+ igt_require(count > 1);
+
+ intel_require_memory(count, size, CHECK_RAM);
+
+ offsets = __captureN(fd, dir, 0, size, count, flags);
+
+ error = igt_sysfs_get(dir, "error");
+ igt_sysfs_set(dir, "error", "Begone!");
+ igt_assert(error);
+
+ blobs = 0;
+ /* render ring --- user = 0x00000000 ffffd000 */
+ for (str = error; (str = strstr(str, "--- user = ")); str++) {
+ uint32_t *data = NULL;
+ unsigned long idx, sz;
+ uint32_t expect;
+ uint32_t hi, lo;
+ uint64_t addr;
+
+ igt_assert(sscanf(str, "--- user = 0x%x %x", &hi, &lo) == 2);
+ addr = hi;
+ addr <<= 32;
+ addr |= lo;
+ for (idx = 0; idx < count; idx++) {
+ if (offsets[idx] == addr)
+ break;
+ }
+ igt_assert(idx < count);
+ igt_debug("offset:%"PRIx64", index:%ld\n", addr, idx);
+
+ str = strchr(str, '\n');
+ if (!str)
+ break;
+
+ str++;
+ if (!(*str == ':' || *str == '~'))
+ continue;
+
+ if (!strchr(str, '\n'))
+ break; /* unterminated -> ENOMEM */
+
+ igt_debug("blob:%.64s\n", str);
+ sz = ascii85_decode(str + 1, &data, *str == ':');
+ igt_assert_eq(4 * sz, size);
+
+ expect = 0;
+ if (flags & INCREMENTAL)
+ expect = idx * size;
+ for (idx = 0; idx < sz; idx++) {
+ igt_assert_eq(data[idx], expect);
+ if (flags & INCREMENTAL)
+ expect++;
+ }
+
+ blobs++;
+ free(data);
+ }
+ igt_info("Captured %lu %"PRId64"-blobs out of a total of %lu\n",
+ blobs, size >> 12, count);
+
+ free(error);
+ free(offsets);
+}
+
static void userptr(int fd, int dir)
{
uint32_t handle;
@@ -179,7 +468,7 @@ static void userptr(int fd, int dir)
igt_assert(posix_memalign(&ptr, 4096, 4096) == 0);
igt_require(__gem_userptr(fd, ptr, 4096, 0, 0, &handle) == 0);
- __capture(fd, dir, 0, handle);
+ __capture1(fd, dir, 0, handle);
gem_close(fd, handle);
free(ptr);
@@ -236,6 +525,31 @@ igt_main
}
}
+ igt_subtest_f("many-4K-zero") {
+ igt_require(gem_can_store_dword(fd, 0));
+ many(fd, dir, 1<<12, 0);
+ }
+
+ igt_subtest_f("many-4K-incremental") {
+ igt_require(gem_can_store_dword(fd, 0));
+ many(fd, dir, 1<<12, INCREMENTAL);
+ }
+
+ igt_subtest_f("many-2M-zero") {
+ igt_require(gem_can_store_dword(fd, 0));
+ many(fd, dir, 2<<20, 0);
+ }
+
+ igt_subtest_f("many-2M-incremental") {
+ igt_require(gem_can_store_dword(fd, 0));
+ many(fd, dir, 2<<20, INCREMENTAL);
+ }
+
+ igt_subtest_f("many-256M-incremental") {
+ igt_require(gem_can_store_dword(fd, 0));
+ many(fd, dir, 256<<20, INCREMENTAL);
+ }
+
/* And check we can read from different types of objects */
igt_subtest_f("userptr") {
diff --git a/tests/intel-ci/blacklist.txt b/tests/intel-ci/blacklist.txt
index 88b2fe313..fa33264df 100644
--- a/tests/intel-ci/blacklist.txt
+++ b/tests/intel-ci/blacklist.txt
@@ -28,6 +28,7 @@ igt@gem_ctx_thrash(@.*)?
igt@gem_evict_alignment(@.*)?
igt@gem_evict_everything(@.*)?
igt@gem_exec_alignment@(?!.*single).*
+igt@gem_exec_capture@many-(?!4K-).*
igt@gem_exec_fence@(?!.*basic).*
igt@gem_exec_flush@(?!.*basic).*
igt@gem_exec_gttfill@(?!.*basic).*
--
2.19.0.rc2
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
