From patchwork Thu Sep 6 17:15:37 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Wilson X-Patchwork-Id: 10590903 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 2B76C13BB for ; Thu, 6 Sep 2018 17:15:50 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 149172AC69 for ; Thu, 6 Sep 2018 17:15:50 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 066C92ACF0; Thu, 6 Sep 2018 17:15:50 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 3B3172AC69 for ; Thu, 6 Sep 2018 17:15:47 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id DD61F6E6FF; Thu, 6 Sep 2018 17:15:45 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from fireflyinternet.com (mail.fireflyinternet.com [109.228.58.192]) by gabe.freedesktop.org (Postfix) with ESMTPS id 93BDF6E6FF for ; Thu, 6 Sep 2018 17:15:44 +0000 (UTC) X-Default-Received-SPF: pass (skip=forwardok (res=PASS)) x-ip-name=78.156.65.138; Received: from haswell.alporthouse.com (unverified [78.156.65.138]) by fireflyinternet.com (Firefly Internet (M1)) with ESMTP id 13617781-1500050 for multiple; Thu, 06 Sep 2018 18:15:36 +0100 From: Chris Wilson To: intel-gfx@lists.freedesktop.org Date: Thu, 6 Sep 2018 18:15:37 +0100 Message-Id: <20180906171537.1288-1-chris@chris-wilson.co.uk> X-Mailer: git-send-email 2.19.0.rc2 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH i-g-t] igt/gem_exec_capture: Capture many, many objects X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Virus-Scanned: ClamAV using ClamSMTP Exercise O(N^2) behaviour in reading the error state, and push it to the extreme. Reported-by: Jason Ekstrand Signed-off-by: Chris Wilson --- 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 + #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).*