Simplify gem_linear_blits

By doing everything manually we can indeed exercise the full GTT.

Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>

diff --git a/tests/gem_linear_blits.c b/tests/gem_linear_blits.c
index 375a5fc..433f550 100644 (file)
--- a/tests/gem_linear_blits.c
+++ b/tests/gem_linear_blits.c
@@ -49,9 +49,32 @@
 #include "intel_batchbuffer.h"
 #include "intel_gpu_tools.h"
 
-static drm_intel_bufmgr *bufmgr;
-struct intel_batchbuffer *batch;
-static int width = 512, height = 512;
+#define WIDTH 512
+#define HEIGHT 512
+
+static uint32_t linear[WIDTH*HEIGHT];
+
+static uint32_t gem_create(int fd, int size)
+{
+       struct drm_i915_gem_create create;
+
+       create.handle = 0;
+       create.size = size;
+       (void)drmIoctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create);
+       assert(create.handle);
+
+       return create.handle;
+}
+
+static void gem_close(int fd, uint32_t handle)
+{
+       struct drm_gem_close close;
+       int ret;
+
+       close.handle = handle;
+       ret = drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &close);
+       assert(ret == 0);
+}
 
 static uint64_t
 gem_aperture_size(int fd)
@@ -63,50 +86,159 @@ gem_aperture_size(int fd)
        return aperture.aper_size;
 }
 
-static drm_intel_bo *
-create_bo(uint32_t start_val)
+static void
+gem_write(int fd, uint32_t handle, int offset, int size, const void *buf)
 {
-       drm_intel_bo *bo;
-       uint32_t *linear;
-       int i;
+       struct drm_i915_gem_pwrite pwrite;
+       int ret;
 
-       bo = drm_intel_bo_alloc(bufmgr, "linear bo", 1024 * 1024, 4096);
+       pwrite.handle = handle;
+       pwrite.offset = offset;
+       pwrite.size = size;
+       pwrite.data_ptr = (uintptr_t)buf;
+       ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite);
+       assert(ret == 0);
+}
 
-       /* Fill the BO with dwords starting at start_val */
-       drm_intel_bo_map(bo, 1);
-       linear = bo->virtual;
-       for (i = 0; i < 1024 * 1024 / 4; i++)
-               linear[i] = start_val++;
-       drm_intel_bo_unmap(bo);
+static void
+gem_read(int fd, uint32_t handle, int offset, int size, void *buf)
+{
+       struct drm_i915_gem_pread pread;
+       int ret;
 
-       return bo;
+       pread.handle = handle;
+       pread.offset = offset;
+       pread.size = size;
+       pread.data_ptr = (uintptr_t)buf;
+       ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_PREAD, &pread);
+       assert(ret == 0);
 }
 
 static void
-check_bo(drm_intel_bo *bo, uint32_t start_val)
+copy(int fd, uint32_t dst, uint32_t src)
 {
-       uint32_t *linear;
+       uint32_t batch[10];
+       struct drm_i915_gem_relocation_entry reloc[2];
+       struct drm_i915_gem_exec_object2 obj[3];
+       struct drm_i915_gem_execbuffer2 exec;
+       uint32_t handle;
+       int ret;
+
+       batch[0] = XY_SRC_COPY_BLT_CMD |
+                 XY_SRC_COPY_BLT_WRITE_ALPHA |
+                 XY_SRC_COPY_BLT_WRITE_RGB;
+       batch[1] = (3 << 24) | /* 32 bits */
+                 (0xcc << 16) | /* copy ROP */
+                 WIDTH*4;
+       batch[2] = 0; /* dst x1,y1 */
+       batch[3] = (HEIGHT << 16) | WIDTH; /* dst x2,y2 */
+       batch[4] = 0; /* dst reloc */
+       batch[5] = 0; /* src x1,y1 */
+       batch[6] = WIDTH*4;
+       batch[7] = 0; /* src reloc */
+       batch[8] = MI_BATCH_BUFFER_END;
+       batch[9] = MI_NOOP;
+
+       handle = gem_create(fd, 4096);
+       gem_write(fd, handle, 0, sizeof(batch), batch);
+
+       reloc[0].target_handle = dst;
+       reloc[0].delta = 0;
+       reloc[0].offset = 4 * sizeof(batch[0]);
+       reloc[0].presumed_offset = 0;
+       reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;;
+       reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
+
+       reloc[1].target_handle = src;
+       reloc[1].delta = 0;
+       reloc[1].offset = 7 * sizeof(batch[0]);
+       reloc[1].presumed_offset = 0;
+       reloc[1].read_domains = I915_GEM_DOMAIN_RENDER;;
+       reloc[1].write_domain = 0;
+
+       obj[0].handle = dst;
+       obj[0].relocation_count = 0;
+       obj[0].relocs_ptr = 0;
+       obj[0].alignment = 0;
+       obj[0].offset = 0;
+       obj[0].flags = 0;
+       obj[0].rsvd1 = 0;
+       obj[0].rsvd2 = 0;
+
+       obj[1].handle = src;
+       obj[1].relocation_count = 0;
+       obj[1].relocs_ptr = 0;
+       obj[1].alignment = 0;
+       obj[1].offset = 0;
+       obj[1].flags = 0;
+       obj[1].rsvd1 = 0;
+       obj[1].rsvd2 = 0;
+
+       obj[2].handle = handle;
+       obj[2].relocation_count = 2;
+       obj[2].relocs_ptr = (uintptr_t)reloc;
+       obj[2].alignment = 0;
+       obj[2].offset = 0;
+       obj[2].flags = 0;
+       obj[2].rsvd1 = obj[2].rsvd2 = 0;
+
+       exec.buffers_ptr = (uintptr_t)obj;
+       exec.buffer_count = 3;
+       exec.batch_start_offset = 0;
+       exec.batch_len = sizeof(batch);
+       exec.DR1 = exec.DR4 = 0;
+       exec.num_cliprects = 0;
+       exec.cliprects_ptr = 0;
+       exec.flags = IS_GEN6(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0;
+       exec.rsvd1 = exec.rsvd2 = 0;
+
+       ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
+       while (ret && errno == EBUSY) {
+               drmCommandNone(fd, DRM_I915_GEM_THROTTLE);
+               ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &exec);
+       }
+       assert(ret == 0);
+
+       gem_close(fd, handle);
+}
+
+static uint32_t
+create_bo(int fd, uint32_t val)
+{
+       uint32_t handle;
        int i;
 
-       drm_intel_bo_map(bo, 0);
-       linear = bo->virtual;
+       handle = gem_create(fd, sizeof(linear));
+
+       /* Fill the BO with dwords starting at val */
+       for (i = 0; i < WIDTH*HEIGHT; i++)
+               linear[i] = val++;
+       gem_write(fd, handle, 0, sizeof(linear), linear);
+
+       return handle;
+}
+
+static void
+check_bo(int fd, uint32_t handle, uint32_t val)
+{
+       int i;
 
-       for (i = 0; i < 1024 * 1024 / 4; i++) {
-               if (linear[i] != start_val) {
+       gem_read(fd, handle, 0, sizeof(linear), linear);
+       for (i = 0; i < WIDTH*HEIGHT; i++) {
+               if (linear[i] != val) {
                        fprintf(stderr, "Expected 0x%08x, found 0x%08x "
                                "at offset 0x%08x\n",
-                               start_val, linear[i], i * 4);
+                               val, linear[i], i * 4);
                        abort();
                }
-               start_val++;
+               val++;
        }
-       drm_intel_bo_unmap(bo);
 }
 
 int main(int argc, char **argv)
 {
-       drm_intel_bo *bo[4096];
-       uint32_t bo_start_val[4096];
+       uint32_t handle[4096];
+       uint32_t start_val[4096];
        uint32_t start = 0;
        int i, fd, count;
 
@@ -116,19 +248,9 @@ int main(int argc, char **argv)
        printf("Using %d 1MiB buffers\n", count);
        assert(count <= 4096);
 
-       bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
-       drm_intel_bufmgr_gem_enable_reuse(bufmgr);
-       batch = intel_batchbuffer_alloc(bufmgr, intel_get_drm_devid(fd));
-
        for (i = 0; i < count; i++) {
-               bo[i] = create_bo(start);
-               bo_start_val[i] = start;
-
-               /*
-               printf("Creating bo %d\n", i);
-               check_bo(bo[i], bo_start_val[i]);
-               */
-
+               handle[i] = create_bo(fd, start);
+               start_val[i] = start;
                start += 1024 * 1024 / 4;
        }
 
@@ -139,29 +261,12 @@ int main(int argc, char **argv)
                if (src == dst)
                        continue;
 
-               intel_copy_bo(batch, bo[dst], bo[src], width, height);
-               bo_start_val[dst] = bo_start_val[src];
-
-               /*
-               check_bo(bo[dst], bo_start_val[dst]);
-               printf("%d: copy bo %d to %d\n", i, src, dst);
-               */
+               copy(fd, handle[dst], handle[src]);
+               start_val[dst] = start_val[src];
        }
 
-       for (i = 0; i < count; i++) {
-               /*
-               printf("check %d\n", i);
-               */
-               check_bo(bo[i], bo_start_val[i]);
-
-               drm_intel_bo_unreference(bo[i]);
-               bo[i] = NULL;
-       }
-
-       intel_batchbuffer_free(batch);
-       drm_intel_bufmgr_destroy(bufmgr);
-
-       close(fd);
+       for (i = 0; i < count; i++)
+               check_bo(fd, handle[i], start_val[i]);
 
        return 0;
 }