[igt-dev] [PATCH i-g-t v8 11/17] tests/xe_intel_bb: Check if intel-bb Xe support correctness

Zbigniew Kempczyński zbigniew.kempczynski at intel.com
Fri Apr 28 08:18:26 UTC 2023


On Fri, Apr 28, 2023 at 09:58:59AM +0200, Kamil Konieczny wrote:
> Hi,
> 
> On 2023-04-28 at 08:22:18 +0200, Zbigniew Kempczyński wrote:
> > As we're reusing intel-bb for Xe we need to check it behaves correctly
> > for buffer handling and submission.
> > 
> > Signed-off-by: Zbigniew Kempczyński <zbigniew.kempczynski at intel.com>
> > Reviewed-by: Christoph Manszewski <christoph.manszewski at intel.com>
> 
> imho it will be more clear to state that you added new test here,
> so instead of:
> 
> tests/xe_intel_bb: Check if intel-bb Xe support correctness
> 
> this will be better:
> 
> tests/xe_intel_bb: add new test for intel-bb on Xe platform
> 
> Then you describe rationale in message. It is up to you if you
> would like to change this, so with or without it:
> 
> Reviewed-by: Kamil Konieczny <kamil.konieczny at linux.intel.com>
> 
> --
> Kamil
> 

Thank you for the review. I'm going to rename subject before merge
when I'll get CI results.

--
Zbigniew

> > 
> > ---
> > v5: to run test quick use system memory instead of vram (mapping
> >     on system is wb)
> > ---
> >  tests/meson.build      |    1 +
> >  tests/xe/xe_intel_bb.c | 1185 ++++++++++++++++++++++++++++++++++++++++
> >  2 files changed, 1186 insertions(+)
> >  create mode 100644 tests/xe/xe_intel_bb.c
> > 
> > diff --git a/tests/meson.build b/tests/meson.build
> > index 8909cfa8fd..b026fac48b 100644
> > --- a/tests/meson.build
> > +++ b/tests/meson.build
> > @@ -256,6 +256,7 @@ xe_progs = [
> >  	'xe_exec_threads',
> >  	'xe_guc_pc',
> >  	'xe_huc_copy',
> > +	'xe_intel_bb',
> >  	'xe_mmap',
> >  	'xe_mmio',
> >  	'xe_module_load',
> > diff --git a/tests/xe/xe_intel_bb.c b/tests/xe/xe_intel_bb.c
> > new file mode 100644
> > index 0000000000..35d61608e1
> > --- /dev/null
> > +++ b/tests/xe/xe_intel_bb.c
> > @@ -0,0 +1,1185 @@
> > +// SPDX-License-Identifier: MIT
> > +/*
> > + * Copyright © 2023 Intel Corporation
> > + */
> > +
> > +#include <cairo.h>
> > +#include <errno.h>
> > +#include <fcntl.h>
> > +#include <glib.h>
> > +#include <inttypes.h>
> > +#include <stdio.h>
> > +#include <stdlib.h>
> > +#include <string.h>
> > +#include <sys/ioctl.h>
> > +#include <sys/stat.h>
> > +#include <unistd.h>
> > +#include <zlib.h>
> > +
> > +#include "igt.h"
> > +#include "igt_crc.h"
> > +#include "intel_bufops.h"
> > +#include "xe/xe_ioctl.h"
> > +#include "xe/xe_query.h"
> > +
> > +/**
> > + * TEST: Basic tests for intel-bb xe functionality
> > + * Category: Software building block
> > + * Sub-category: xe
> > + * Test category: functionality test
> > + */
> > +
> > +#define PAGE_SIZE 4096
> > +
> > +#define WIDTH	64
> > +#define HEIGHT	64
> > +#define STRIDE	(WIDTH * 4)
> > +#define SIZE	(HEIGHT * STRIDE)
> > +
> > +#define COLOR_00	0x00
> > +#define COLOR_33	0x33
> > +#define COLOR_77	0x77
> > +#define COLOR_CC	0xcc
> > +
> > +IGT_TEST_DESCRIPTION("xe_intel_bb API check.");
> > +
> > +static bool debug_bb;
> > +static bool write_png;
> > +static bool buf_info;
> > +static bool print_base64;
> > +
> > +static void *alloc_aligned(uint64_t size)
> > +{
> > +	void *p;
> > +
> > +	igt_assert_eq(posix_memalign(&p, 16, size), 0);
> > +
> > +	return p;
> > +}
> > +
> > +static void fill_buf(struct intel_buf *buf, uint8_t color)
> > +{
> > +	uint8_t *ptr;
> > +	int xe = buf_ops_get_fd(buf->bops);
> > +	int i;
> > +
> > +	ptr = xe_bo_map(xe, buf->handle, buf->surface[0].size);
> > +
> > +	for (i = 0; i < buf->surface[0].size; i++)
> > +		ptr[i] = color;
> > +
> > +	munmap(ptr, buf->surface[0].size);
> > +}
> > +
> > +static void check_buf(struct intel_buf *buf, uint8_t color)
> > +{
> > +	uint8_t *ptr;
> > +	int xe = buf_ops_get_fd(buf->bops);
> > +	int i;
> > +
> > +	ptr = xe_bo_map(xe, buf->handle, buf->surface[0].size);
> > +
> > +	for (i = 0; i < buf->surface[0].size; i++)
> > +		igt_assert(ptr[i] == color);
> > +
> > +	munmap(ptr, buf->surface[0].size);
> > +}
> > +
> > +static struct intel_buf *
> > +create_buf(struct buf_ops *bops, int width, int height, uint8_t color)
> > +{
> > +	struct intel_buf *buf;
> > +
> > +	buf = calloc(1, sizeof(*buf));
> > +	igt_assert(buf);
> > +
> > +	intel_buf_init(bops, buf, width/4, height, 32, 0, I915_TILING_NONE, 0);
> > +	fill_buf(buf, color);
> > +
> > +	return buf;
> > +}
> > +
> > +static void print_buf(struct intel_buf *buf, const char *name)
> > +{
> > +	uint8_t *ptr;
> > +	int xe = buf_ops_get_fd(buf->bops);
> > +
> > +	ptr = xe_bo_map(xe, buf->handle, buf->surface[0].size);
> > +
> > +	igt_debug("[%s] Buf handle: %d, size: %" PRIu64
> > +		  ", v: 0x%02x, presumed_addr: %p\n",
> > +		  name, buf->handle, buf->surface[0].size, ptr[0],
> > +		  from_user_pointer(buf->addr.offset));
> > +	munmap(ptr, buf->surface[0].size);
> > +}
> > +
> > +/**
> > + * SUBTEST: reset-bb
> > + * Description: check bb reset
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void reset_bb(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	intel_bb_reset(ibb, false);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: purge-bb
> > + * Description: check bb reset == full (purge)
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void purge_bb(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_buf *buf;
> > +	struct intel_bb *ibb;
> > +	uint64_t offset0, offset1;
> > +
> > +	buf = intel_buf_create(bops, 512, 512, 32, 0, I915_TILING_NONE,
> > +			       I915_COMPRESSION_NONE);
> > +	ibb = intel_bb_create(xe, 4096);
> > +	intel_bb_set_debug(ibb, true);
> > +
> > +	intel_bb_add_intel_buf(ibb, buf, false);
> > +	offset0 = buf->addr.offset;
> > +
> > +	intel_bb_reset(ibb, true);
> > +	buf->addr.offset = INTEL_BUF_INVALID_ADDRESS;
> > +
> > +	intel_bb_add_intel_buf(ibb, buf, false);
> > +	offset1 = buf->addr.offset;
> > +
> > +	igt_assert(offset0 == offset1);
> > +
> > +	intel_buf_destroy(buf);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: simple-%s
> > + * Description: Run simple bb xe %arg[1] test
> > + * Run type: BAT
> > + *
> > + * arg[1]:
> > + *
> > + * @bb:     bb
> > + * @bb-ctx: bb-ctx
> > + */
> > +static void simple_bb(struct buf_ops *bops, bool new_context)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	uint32_t ctx = 0;
> > +
> > +	ibb = intel_bb_create_with_allocator(xe, ctx, NULL, PAGE_SIZE,
> > +					     INTEL_ALLOCATOR_SIMPLE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	intel_bb_out(ibb, MI_BATCH_BUFFER_END);
> > +	intel_bb_ptr_align(ibb, 8);
> > +
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +
> > +	/* Check we're safe with reset and no double-free will occur */
> > +	intel_bb_reset(ibb, true);
> > +	intel_bb_reset(ibb, false);
> > +	intel_bb_reset(ibb, true);
> > +
> > +	if (new_context) {
> > +		ctx = xe_vm_create(xe, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
> > +		intel_bb_destroy(ibb);
> > +		ibb = intel_bb_create_with_context(xe, ctx, NULL, PAGE_SIZE);
> > +		intel_bb_out(ibb, MI_BATCH_BUFFER_END);
> > +		intel_bb_ptr_align(ibb, 8);
> > +		intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +			      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC,
> > +			      true);
> > +		xe_vm_destroy(xe, ctx);
> > +	}
> > +
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: bb-with-allocator
> > + * Description: check bb with passed allocator
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void bb_with_allocator(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf *src, *dst;
> > +	uint32_t ctx = 0;
> > +
> > +	ibb = intel_bb_create_with_allocator(xe, ctx, NULL, PAGE_SIZE,
> > +					     INTEL_ALLOCATOR_SIMPLE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	src = intel_buf_create(bops, 4096/32, 32, 8, 0, I915_TILING_NONE,
> > +			       I915_COMPRESSION_NONE);
> > +	dst = intel_buf_create(bops, 4096/32, 32, 8, 0, I915_TILING_NONE,
> > +			       I915_COMPRESSION_NONE);
> > +
> > +	intel_bb_add_intel_buf(ibb, src, false);
> > +	intel_bb_add_intel_buf(ibb, dst, true);
> > +	intel_bb_copy_intel_buf(ibb, dst, src, 4096);
> > +	intel_bb_remove_intel_buf(ibb, src);
> > +	intel_bb_remove_intel_buf(ibb, dst);
> > +
> > +	intel_buf_destroy(src);
> > +	intel_buf_destroy(dst);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: lot-of-buffers
> > + * Description: check running bb with many buffers
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +#define NUM_BUFS 500
> > +static void lot_of_buffers(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf *buf[NUM_BUFS];
> > +	int i;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	intel_bb_out(ibb, MI_BATCH_BUFFER_END);
> > +	intel_bb_ptr_align(ibb, 8);
> > +
> > +	for (i = 0; i < NUM_BUFS; i++) {
> > +		buf[i] = intel_buf_create(bops, 4096, 1, 8, 0, I915_TILING_NONE,
> > +					  I915_COMPRESSION_NONE);
> > +		if (i % 2)
> > +			intel_bb_add_intel_buf(ibb, buf[i], false);
> > +		else
> > +			intel_bb_add_intel_buf_with_alignment(ibb, buf[i],
> > +							      0x4000, false);
> > +	}
> > +
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +
> > +	for (i = 0; i < NUM_BUFS; i++)
> > +		intel_buf_destroy(buf[i]);
> > +
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: add-remove-objects
> > + * Description: check bb object manipulation (add + remove)
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void add_remove_objects(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf *src, *mid, *dst;
> > +	uint32_t offset;
> > +	const uint32_t width = 512;
> > +	const uint32_t height = 512;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	src = intel_buf_create(bops, width, height, 32, 0,
> > +			       I915_TILING_NONE, I915_COMPRESSION_NONE);
> > +	mid = intel_buf_create(bops, width, height, 32, 0,
> > +			       I915_TILING_NONE, I915_COMPRESSION_NONE);
> > +	dst = intel_buf_create(bops, width, height, 32, 0,
> > +			       I915_TILING_NONE, I915_COMPRESSION_NONE);
> > +
> > +	intel_bb_add_intel_buf(ibb, src, false);
> > +	intel_bb_add_intel_buf(ibb, mid, true);
> > +	intel_bb_remove_intel_buf(ibb, mid);
> > +	intel_bb_remove_intel_buf(ibb, mid);
> > +	intel_bb_remove_intel_buf(ibb, mid);
> > +	intel_bb_add_intel_buf(ibb, dst, true);
> > +
> > +	offset = intel_bb_emit_bbe(ibb);
> > +	intel_bb_exec(ibb, offset,
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +
> > +	intel_buf_destroy(src);
> > +	intel_buf_destroy(mid);
> > +	intel_buf_destroy(dst);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: destroy-bb
> > + * Description: check bb destroy/create
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void destroy_bb(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf *src, *mid, *dst;
> > +	uint32_t offset;
> > +	const uint32_t width = 512;
> > +	const uint32_t height = 512;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	src = intel_buf_create(bops, width, height, 32, 0,
> > +			       I915_TILING_NONE, I915_COMPRESSION_NONE);
> > +	mid = intel_buf_create(bops, width, height, 32, 0,
> > +			       I915_TILING_NONE, I915_COMPRESSION_NONE);
> > +	dst = intel_buf_create(bops, width, height, 32, 0,
> > +			       I915_TILING_NONE, I915_COMPRESSION_NONE);
> > +
> > +	intel_bb_add_intel_buf(ibb, src, false);
> > +	intel_bb_add_intel_buf(ibb, mid, true);
> > +	intel_bb_add_intel_buf(ibb, dst, true);
> > +
> > +	offset = intel_bb_emit_bbe(ibb);
> > +	intel_bb_exec(ibb, offset,
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +
> > +	/* Check destroy will detach intel_bufs */
> > +	intel_bb_destroy(ibb);
> > +	igt_assert(src->addr.offset == INTEL_BUF_INVALID_ADDRESS);
> > +	igt_assert(src->ibb == NULL);
> > +	igt_assert(mid->addr.offset == INTEL_BUF_INVALID_ADDRESS);
> > +	igt_assert(mid->ibb == NULL);
> > +	igt_assert(dst->addr.offset == INTEL_BUF_INVALID_ADDRESS);
> > +	igt_assert(dst->ibb == NULL);
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	intel_bb_add_intel_buf(ibb, src, false);
> > +	offset = intel_bb_emit_bbe(ibb);
> > +	intel_bb_exec(ibb, offset,
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +
> > +	intel_bb_destroy(ibb);
> > +	intel_buf_destroy(src);
> > +	intel_buf_destroy(mid);
> > +	intel_buf_destroy(dst);
> > +}
> > +
> > +/**
> > + * SUBTEST: create-in-region
> > + * Description: check size validation on available regions
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void create_in_region(struct buf_ops *bops, uint64_t region)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf buf = {};
> > +	uint32_t handle, offset;
> > +	uint64_t size;
> > +	int width = 64;
> > +	int height = 64;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	size = xe_min_page_size(xe, system_memory(xe));
> > +	handle = xe_bo_create_flags(xe, 0, size, system_memory(xe));
> > +	intel_buf_init_full(bops, handle, &buf,
> > +			    width/4, height, 32, 0,
> > +			    I915_TILING_NONE, 0,
> > +			    size, 0, region);
> > +	intel_buf_set_ownership(&buf, true);
> > +
> > +	intel_bb_add_intel_buf(ibb, &buf, false);
> > +	offset = intel_bb_emit_bbe(ibb);
> > +	intel_bb_exec(ibb, offset,
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +
> > +	intel_buf_close(bops, &buf);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +static void __emit_blit(struct intel_bb *ibb,
> > +			 struct intel_buf *src, struct intel_buf *dst)
> > +{
> > +	intel_bb_emit_blt_copy(ibb,
> > +			       src, 0, 0, src->surface[0].stride,
> > +			       dst, 0, 0, dst->surface[0].stride,
> > +			       intel_buf_width(dst),
> > +			       intel_buf_height(dst),
> > +			       dst->bpp);
> > +}
> > +
> > +/**
> > + * SUBTEST: blit-%s
> > + * Description: Run blit on %arg[1] allocator
> > + * Run type: BAT
> > + *
> > + * arg[1]:
> > + *
> > + * @simple:				simple
> > + * @reloc:				reloc
> > + */
> > +static void blit(struct buf_ops *bops, uint8_t allocator_type)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf *src, *dst;
> > +	uint64_t poff_src, poff_dst;
> > +	uint64_t flags = 0;
> > +
> > +	ibb = intel_bb_create_with_allocator(xe, 0, NULL, PAGE_SIZE,
> > +					     allocator_type);
> > +	flags |= I915_EXEC_NO_RELOC;
> > +
> > +	src = create_buf(bops, WIDTH, HEIGHT, COLOR_CC);
> > +	dst = create_buf(bops, WIDTH, HEIGHT, COLOR_00);
> > +
> > +	if (buf_info) {
> > +		print_buf(src, "src");
> > +		print_buf(dst, "dst");
> > +	}
> > +
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	__emit_blit(ibb, src, dst);
> > +	intel_bb_emit_bbe(ibb);
> > +	intel_bb_flush_blit(ibb);
> > +	intel_bb_sync(ibb);
> > +	intel_bb_reset(ibb, false);
> > +	check_buf(dst, COLOR_CC);
> > +
> > +	poff_src = intel_bb_get_object_offset(ibb, src->handle);
> > +	poff_dst = intel_bb_get_object_offset(ibb, dst->handle);
> > +
> > +	/* Add buffers again */
> > +	intel_bb_add_intel_buf(ibb, src, false);
> > +	intel_bb_add_intel_buf(ibb, dst, true);
> > +
> > +	igt_assert_f(poff_src == src->addr.offset,
> > +		     "prev src addr: %" PRIx64 " <> src addr %" PRIx64 "\n",
> > +		     poff_src, src->addr.offset);
> > +	igt_assert_f(poff_dst == dst->addr.offset,
> > +		     "prev dst addr: %" PRIx64 " <> dst addr %" PRIx64 "\n",
> > +		     poff_dst, dst->addr.offset);
> > +
> > +	fill_buf(src, COLOR_77);
> > +	fill_buf(dst, COLOR_00);
> > +
> > +	__emit_blit(ibb, src, dst);
> > +	intel_bb_emit_bbe(ibb);
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +	check_buf(dst, COLOR_77);
> > +
> > +	intel_bb_emit_bbe(ibb);
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +	check_buf(dst, COLOR_77);
> > +
> > +	intel_buf_destroy(src);
> > +	intel_buf_destroy(dst);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +static void scratch_buf_init(struct buf_ops *bops,
> > +			     struct intel_buf *buf,
> > +			     int width, int height,
> > +			     uint32_t req_tiling,
> > +			     enum i915_compression compression)
> > +{
> > +	int fd = buf_ops_get_fd(bops);
> > +	int bpp = 32;
> > +
> > +	/*
> > +	 * We use system memory even if vram is possible because wc mapping
> > +	 * is extremely slow.
> > +	 */
> > +	intel_buf_init_in_region(bops, buf, width, height, bpp, 0,
> > +				 req_tiling, compression,
> > +				 system_memory(fd));
> > +
> > +	igt_assert(intel_buf_width(buf) == width);
> > +	igt_assert(intel_buf_height(buf) == height);
> > +}
> > +
> > +static void scratch_buf_draw_pattern(struct buf_ops *bops,
> > +				     struct intel_buf *buf,
> > +				     int x, int y, int w, int h,
> > +				     int cx, int cy, int cw, int ch,
> > +				     bool use_alternate_colors)
> > +{
> > +	cairo_surface_t *surface;
> > +	cairo_pattern_t *pat;
> > +	cairo_t *cr;
> > +	void *linear;
> > +
> > +	linear = alloc_aligned(buf->surface[0].size);
> > +
> > +	surface = cairo_image_surface_create_for_data(linear,
> > +						      CAIRO_FORMAT_RGB24,
> > +						      intel_buf_width(buf),
> > +						      intel_buf_height(buf),
> > +						      buf->surface[0].stride);
> > +
> > +	cr = cairo_create(surface);
> > +
> > +	cairo_rectangle(cr, cx, cy, cw, ch);
> > +	cairo_clip(cr);
> > +
> > +	pat = cairo_pattern_create_mesh();
> > +	cairo_mesh_pattern_begin_patch(pat);
> > +	cairo_mesh_pattern_move_to(pat, x,   y);
> > +	cairo_mesh_pattern_line_to(pat, x+w, y);
> > +	cairo_mesh_pattern_line_to(pat, x+w, y+h);
> > +	cairo_mesh_pattern_line_to(pat, x,   y+h);
> > +	if (use_alternate_colors) {
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 0, 0.0, 1.0, 1.0);
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 1, 1.0, 0.0, 1.0);
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 2, 1.0, 1.0, 0.0);
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 3, 0.0, 0.0, 0.0);
> > +	} else {
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 0, 1.0, 0.0, 0.0);
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 1, 0.0, 1.0, 0.0);
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 2, 0.0, 0.0, 1.0);
> > +		cairo_mesh_pattern_set_corner_color_rgb(pat, 3, 1.0, 1.0, 1.0);
> > +	}
> > +	cairo_mesh_pattern_end_patch(pat);
> > +
> > +	cairo_rectangle(cr, x, y, w, h);
> > +	cairo_set_source(cr, pat);
> > +	cairo_fill(cr);
> > +	cairo_pattern_destroy(pat);
> > +
> > +	cairo_destroy(cr);
> > +
> > +	cairo_surface_destroy(surface);
> > +
> > +	linear_to_intel_buf(bops, buf, linear);
> > +
> > +	free(linear);
> > +}
> > +
> > +#define GROUP_SIZE 4096
> > +static int compare_detail(const uint32_t *ptr1, uint32_t *ptr2,
> > +			  uint32_t size)
> > +{
> > +	int i, ok = 0, fail = 0;
> > +	int groups = size / GROUP_SIZE;
> > +	int *hist = calloc(GROUP_SIZE, groups);
> > +
> > +	igt_debug("size: %d, group_size: %d, groups: %d\n",
> > +		  size, GROUP_SIZE, groups);
> > +
> > +	for (i = 0; i < size / sizeof(uint32_t); i++) {
> > +		if (ptr1[i] == ptr2[i]) {
> > +			ok++;
> > +		} else {
> > +			fail++;
> > +			hist[i * sizeof(uint32_t) / GROUP_SIZE]++;
> > +		}
> > +	}
> > +
> > +	for (i = 0; i < groups; i++) {
> > +		if (hist[i])
> > +			igt_debug("[group %4x]: %d\n", i, hist[i]);
> > +	}
> > +	free(hist);
> > +
> > +	igt_debug("ok: %d, fail: %d\n", ok, fail);
> > +
> > +	return fail;
> > +}
> > +
> > +static int compare_bufs(struct intel_buf *buf1, struct intel_buf *buf2,
> > +			 bool detail_compare)
> > +{
> > +	void *ptr1, *ptr2;
> > +	int fd1, fd2, ret;
> > +
> > +	igt_assert(buf1->surface[0].size == buf2->surface[0].size);
> > +
> > +	fd1 = buf_ops_get_fd(buf1->bops);
> > +	fd2 = buf_ops_get_fd(buf2->bops);
> > +
> > +	ptr1 = xe_bo_map(fd1, buf1->handle, buf1->surface[0].size);
> > +	ptr2 = xe_bo_map(fd2, buf2->handle, buf2->surface[0].size);
> > +	ret = memcmp(ptr1, ptr2, buf1->surface[0].size);
> > +	if (detail_compare)
> > +		ret = compare_detail(ptr1, ptr2, buf1->surface[0].size);
> > +
> > +	munmap(ptr1, buf1->surface[0].size);
> > +	munmap(ptr2, buf2->surface[0].size);
> > +
> > +	return ret;
> > +}
> > +
> > +#define LINELEN 76ul
> > +static int dump_base64(const char *name, struct intel_buf *buf)
> > +{
> > +	void *ptr;
> > +	int fd, ret;
> > +	uLongf outsize = buf->surface[0].size * 3 / 2;
> > +	Bytef *destbuf = malloc(outsize);
> > +	gchar *str, *pos;
> > +
> > +	fd = buf_ops_get_fd(buf->bops);
> > +
> > +	ptr = gem_mmap__device_coherent(fd, buf->handle, 0,
> > +					buf->surface[0].size, PROT_READ);
> > +
> > +	ret = compress2(destbuf, &outsize, ptr, buf->surface[0].size,
> > +			Z_BEST_COMPRESSION);
> > +	if (ret != Z_OK) {
> > +		igt_warn("error compressing, ret: %d\n", ret);
> > +	} else {
> > +		igt_info("compressed %" PRIu64 " -> %lu\n",
> > +			 buf->surface[0].size, outsize);
> > +
> > +		igt_info("--- %s ---\n", name);
> > +		pos = str = g_base64_encode(destbuf, outsize);
> > +		outsize = strlen(str);
> > +		while (pos) {
> > +			char line[LINELEN + 1];
> > +			int to_copy = min(LINELEN, outsize);
> > +
> > +			memcpy(line, pos, to_copy);
> > +			line[to_copy] = 0;
> > +			igt_info("%s\n", line);
> > +			pos += LINELEN;
> > +			outsize -= to_copy;
> > +
> > +			if (outsize == 0)
> > +				break;
> > +		}
> > +		free(str);
> > +	}
> > +
> > +	munmap(ptr, buf->surface[0].size);
> > +	free(destbuf);
> > +
> > +	return ret;
> > +}
> > +
> > +static int __do_intel_bb_blit(struct buf_ops *bops, uint32_t tiling)
> > +{
> > +	struct intel_bb *ibb;
> > +	const int width = 1024;
> > +	const int height = 1024;
> > +	struct intel_buf src, dst, final;
> > +	char name[128];
> > +	int xe = buf_ops_get_fd(bops), fails;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	scratch_buf_init(bops, &src, width, height, I915_TILING_NONE,
> > +			 I915_COMPRESSION_NONE);
> > +	scratch_buf_init(bops, &dst, width, height, tiling,
> > +			 I915_COMPRESSION_NONE);
> > +	scratch_buf_init(bops, &final, width, height, I915_TILING_NONE,
> > +			 I915_COMPRESSION_NONE);
> > +
> > +	if (buf_info) {
> > +		intel_buf_print(&src);
> > +		intel_buf_print(&dst);
> > +	}
> > +
> > +	scratch_buf_draw_pattern(bops, &src,
> > +				 0, 0, width, height,
> > +				 0, 0, width, height, 0);
> > +
> > +	intel_bb_blt_copy(ibb,
> > +			  &src, 0, 0, src.surface[0].stride,
> > +			  &dst, 0, 0, dst.surface[0].stride,
> > +			  intel_buf_width(&dst),
> > +			  intel_buf_height(&dst),
> > +			  dst.bpp);
> > +
> > +	intel_bb_blt_copy(ibb,
> > +			  &dst, 0, 0, dst.surface[0].stride,
> > +			  &final, 0, 0, final.surface[0].stride,
> > +			  intel_buf_width(&dst),
> > +			  intel_buf_height(&dst),
> > +			  dst.bpp);
> > +
> > +	igt_assert(intel_bb_sync(ibb) == 0);
> > +	intel_bb_destroy(ibb);
> > +
> > +	if (write_png) {
> > +		snprintf(name, sizeof(name) - 1,
> > +			 "bb_blit_dst_tiling_%d.png", tiling);
> > +		intel_buf_write_to_png(&src, "bb_blit_src_tiling_none.png");
> > +		intel_buf_write_to_png(&dst, name);
> > +		intel_buf_write_to_png(&final, "bb_blit_final_tiling_none.png");
> > +	}
> > +
> > +	/* We'll fail on src <-> final compare so just warn */
> > +	if (tiling == I915_TILING_NONE) {
> > +		if (compare_bufs(&src, &dst, false) > 0)
> > +			igt_warn("none->none blit failed!");
> > +	} else {
> > +		if (compare_bufs(&src, &dst, false) == 0)
> > +			igt_warn("none->tiled blit failed!");
> > +	}
> > +
> > +	fails = compare_bufs(&src, &final, true);
> > +
> > +	intel_buf_close(bops, &src);
> > +	intel_buf_close(bops, &dst);
> > +	intel_buf_close(bops, &final);
> > +
> > +	return fails;
> > +}
> > +
> > +/**
> > + * SUBTEST: intel-bb-blit-%s
> > + * Description: Run simple bb xe %arg[1] test
> > + * Run type: BAT
> > + *
> > + * arg[1]:
> > + *
> > + * @none:				none
> > + * @x:					x
> > + * @y:					y
> > + */
> > +static void do_intel_bb_blit(struct buf_ops *bops, int loops, uint32_t tiling)
> > +{
> > +	int i, fails = 0, xe = buf_ops_get_fd(bops);
> > +
> > +	/* We'll fix it for gen2/3 later. */
> > +	igt_require(intel_gen(intel_get_drm_devid(xe)) > 3);
> > +
> > +	for (i = 0; i < loops; i++)
> > +		fails += __do_intel_bb_blit(bops, tiling);
> > +
> > +	igt_assert_f(fails == 0, "intel-bb-blit (tiling: %d) fails: %d\n",
> > +		     tiling, fails);
> > +}
> > +
> > +/**
> > + * SUBTEST: offset-control
> > + * Description: check offset is kept on default simple allocator
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void offset_control(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	struct intel_buf *src, *dst1, *dst2, *dst3;
> > +	uint64_t poff_src, poff_dst1, poff_dst2;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	src = create_buf(bops, WIDTH, HEIGHT, COLOR_CC);
> > +	dst1 = create_buf(bops, WIDTH, HEIGHT, COLOR_00);
> > +	dst2 = create_buf(bops, WIDTH, HEIGHT, COLOR_77);
> > +
> > +	intel_bb_add_object(ibb, src->handle, intel_buf_bo_size(src),
> > +			    src->addr.offset, 0, false);
> > +	intel_bb_add_object(ibb, dst1->handle, intel_buf_bo_size(dst1),
> > +			    dst1->addr.offset, 0, true);
> > +	intel_bb_add_object(ibb, dst2->handle, intel_buf_bo_size(dst2),
> > +			    dst2->addr.offset, 0, true);
> > +
> > +	intel_bb_out(ibb, MI_BATCH_BUFFER_END);
> > +	intel_bb_ptr_align(ibb, 8);
> > +
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, false);
> > +
> > +	if (buf_info) {
> > +		print_buf(src, "src ");
> > +		print_buf(dst1, "dst1");
> > +		print_buf(dst2, "dst2");
> > +	}
> > +
> > +	poff_src = src->addr.offset;
> > +	poff_dst1 = dst1->addr.offset;
> > +	poff_dst2 = dst2->addr.offset;
> > +	intel_bb_reset(ibb, true);
> > +
> > +	dst3 = create_buf(bops, WIDTH, HEIGHT, COLOR_33);
> > +	intel_bb_add_object(ibb, dst3->handle, intel_buf_bo_size(dst3),
> > +			    dst3->addr.offset, 0, true);
> > +	intel_bb_add_object(ibb, src->handle, intel_buf_bo_size(src),
> > +			    src->addr.offset, 0, false);
> > +	intel_bb_add_object(ibb, dst1->handle, intel_buf_bo_size(dst1),
> > +			    dst1->addr.offset, 0, true);
> > +	intel_bb_add_object(ibb, dst2->handle, intel_buf_bo_size(dst2),
> > +			    dst2->addr.offset, 0, true);
> > +
> > +	intel_bb_out(ibb, MI_BATCH_BUFFER_END);
> > +	intel_bb_ptr_align(ibb, 8);
> > +
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, false);
> > +	intel_bb_sync(ibb);
> > +	intel_bb_reset(ibb, true);
> > +
> > +	igt_assert(poff_src == src->addr.offset);
> > +	igt_assert(poff_dst1 == dst1->addr.offset);
> > +	igt_assert(poff_dst2 == dst2->addr.offset);
> > +
> > +	if (buf_info) {
> > +		print_buf(src, "src ");
> > +		print_buf(dst1, "dst1");
> > +		print_buf(dst2, "dst2");
> > +	}
> > +
> > +	intel_buf_destroy(src);
> > +	intel_buf_destroy(dst1);
> > +	intel_buf_destroy(dst2);
> > +	intel_buf_destroy(dst3);
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/*
> > + * Idea of the test is to verify delta is properly added to address
> > + * when emit_reloc() is called.
> > + */
> > +
> > +/**
> > + * SUBTEST: delta-check
> > + * Description: check delta is honoured in intel-bb pipelines
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +#define DELTA_BUFFERS 3
> > +static void delta_check(struct buf_ops *bops)
> > +{
> > +	const uint32_t expected = 0x1234abcd;
> > +	int xe = buf_ops_get_fd(bops);
> > +	uint32_t *ptr, hi, lo, val;
> > +	struct intel_buf *buf;
> > +	struct intel_bb *ibb;
> > +	uint64_t offset;
> > +	uint64_t obj_size = xe_get_default_alignment(xe) + 0x2000;
> > +	uint64_t obj_offset = (1ULL << 32) - xe_get_default_alignment(xe);
> > +	uint64_t delta = xe_get_default_alignment(xe) + 0x1000;
> > +
> > +	ibb = intel_bb_create_with_allocator(xe, 0, NULL, PAGE_SIZE,
> > +					     INTEL_ALLOCATOR_SIMPLE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	buf = create_buf(bops, obj_size, 0x1, COLOR_CC);
> > +	buf->addr.offset = obj_offset;
> > +	intel_bb_add_object(ibb, buf->handle, intel_buf_bo_size(buf),
> > +			    buf->addr.offset, 0, false);
> > +
> > +	intel_bb_out(ibb, MI_STORE_DWORD_IMM_GEN4);
> > +	intel_bb_emit_reloc(ibb, buf->handle,
> > +			    I915_GEM_DOMAIN_RENDER,
> > +			    I915_GEM_DOMAIN_RENDER,
> > +			    delta, buf->addr.offset);
> > +	intel_bb_out(ibb, expected);
> > +
> > +	intel_bb_out(ibb, MI_BATCH_BUFFER_END);
> > +	intel_bb_ptr_align(ibb, 8);
> > +
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb), I915_EXEC_DEFAULT, false);
> > +	intel_bb_sync(ibb);
> > +
> > +	/* Buffer should be @ obj_offset */
> > +	offset = intel_bb_get_object_offset(ibb, buf->handle);
> > +	igt_assert_eq_u64(offset, obj_offset);
> > +
> > +	ptr = xe_bo_map(xe, ibb->handle, ibb->size);
> > +	lo = ptr[1];
> > +	hi = ptr[2];
> > +	gem_munmap(ptr, ibb->size);
> > +
> > +	ptr = xe_bo_map(xe, buf->handle, intel_buf_size(buf));
> > +	val = ptr[delta / sizeof(uint32_t)];
> > +	gem_munmap(ptr, intel_buf_size(buf));
> > +
> > +	intel_buf_destroy(buf);
> > +	intel_bb_destroy(ibb);
> > +
> > +	/* Assert after all resources are freed */
> > +	igt_assert_f(lo == 0x1000 && hi == 0x1,
> > +		     "intel-bb doesn't properly handle delta in emit relocation\n");
> > +	igt_assert_f(val == expected,
> > +		     "Address doesn't contain expected [%x] value [%x]\n",
> > +		     expected, val);
> > +}
> > +
> > +/**
> > + * SUBTEST: full-batch
> > + * Description: check bb totally filled is executing correct
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static void full_batch(struct buf_ops *bops)
> > +{
> > +	int xe = buf_ops_get_fd(bops);
> > +	struct intel_bb *ibb;
> > +	int i;
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	for (i = 0; i < PAGE_SIZE / sizeof(uint32_t) - 1; i++)
> > +		intel_bb_out(ibb, 0);
> > +	intel_bb_emit_bbe(ibb);
> > +
> > +	igt_assert(intel_bb_offset(ibb) == PAGE_SIZE);
> > +	intel_bb_exec(ibb, intel_bb_offset(ibb),
> > +		      I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, true);
> > +	intel_bb_reset(ibb, false);
> > +
> > +	intel_bb_destroy(ibb);
> > +}
> > +
> > +/**
> > + * SUBTEST: render
> > + * Description: check intel-bb render pipeline
> > + * Run type: FULL
> > + * TODO: change ``'Run type' == FULL`` to a better category
> > + */
> > +static int render(struct buf_ops *bops, uint32_t tiling,
> > +		  uint32_t width, uint32_t height)
> > +{
> > +	struct intel_bb *ibb;
> > +	struct intel_buf src, dst, final;
> > +	int xe = buf_ops_get_fd(bops);
> > +	uint32_t fails = 0;
> > +	char name[128];
> > +	uint32_t devid = intel_get_drm_devid(xe);
> > +	igt_render_copyfunc_t render_copy = NULL;
> > +
> > +	igt_debug("%s() gen: %d\n", __func__, intel_gen(devid));
> > +
> > +	ibb = intel_bb_create(xe, PAGE_SIZE);
> > +
> > +	if (debug_bb)
> > +		intel_bb_set_debug(ibb, true);
> > +
> > +	if (print_base64)
> > +		intel_bb_set_dump_base64(ibb, true);
> > +
> > +	scratch_buf_init(bops, &src, width, height, I915_TILING_NONE,
> > +			 I915_COMPRESSION_NONE);
> > +	scratch_buf_init(bops, &dst, width, height, tiling,
> > +			 I915_COMPRESSION_NONE);
> > +	scratch_buf_init(bops, &final, width, height, I915_TILING_NONE,
> > +			 I915_COMPRESSION_NONE);
> > +
> > +	scratch_buf_draw_pattern(bops, &src,
> > +				 0, 0, width, height,
> > +				 0, 0, width, height, 0);
> > +
> > +	render_copy = igt_get_render_copyfunc(devid);
> > +	igt_assert(render_copy);
> > +
> > +	render_copy(ibb,
> > +		    &src,
> > +		    0, 0, width, height,
> > +		    &dst,
> > +		    0, 0);
> > +
> > +	render_copy(ibb,
> > +		    &dst,
> > +		    0, 0, width, height,
> > +		    &final,
> > +		    0, 0);
> > +
> > +	intel_bb_sync(ibb);
> > +	intel_bb_destroy(ibb);
> > +
> > +	if (write_png) {
> > +		snprintf(name, sizeof(name) - 1,
> > +			 "render_dst_tiling_%d.png", tiling);
> > +		intel_buf_write_to_png(&src, "render_src_tiling_none.png");
> > +		intel_buf_write_to_png(&dst, name);
> > +		intel_buf_write_to_png(&final, "render_final_tiling_none.png");
> > +	}
> > +
> > +	/* We'll fail on src <-> final compare so just warn */
> > +	if (tiling == I915_TILING_NONE) {
> > +		if (compare_bufs(&src, &dst, false) > 0)
> > +			igt_warn("%s: none->none failed!\n", __func__);
> > +	} else {
> > +		if (compare_bufs(&src, &dst, false) == 0)
> > +			igt_warn("%s: none->tiled failed!\n", __func__);
> > +	}
> > +
> > +	fails = compare_bufs(&src, &final, true);
> > +
> > +	if (fails && print_base64) {
> > +		dump_base64("src", &src);
> > +		dump_base64("dst", &dst);
> > +		dump_base64("final", &final);
> > +	}
> > +
> > +	intel_buf_close(bops, &src);
> > +	intel_buf_close(bops, &dst);
> > +	intel_buf_close(bops, &final);
> > +
> > +	igt_assert_f(fails == 0, "%s: (tiling: %d) fails: %d\n",
> > +		     __func__, tiling, fails);
> > +
> > +	return fails;
> > +}
> > +
> > +static int opt_handler(int opt, int opt_index, void *data)
> > +{
> > +	switch (opt) {
> > +	case 'd':
> > +		debug_bb = true;
> > +		break;
> > +	case 'p':
> > +		write_png = true;
> > +		break;
> > +	case 'i':
> > +		buf_info = true;
> > +		break;
> > +	case 'b':
> > +		print_base64 = true;
> > +		break;
> > +	default:
> > +		return IGT_OPT_HANDLER_ERROR;
> > +	}
> > +
> > +	return IGT_OPT_HANDLER_SUCCESS;
> > +}
> > +
> > +const char *help_str =
> > +	"  -d\tDebug bb\n"
> > +	"  -p\tWrite surfaces to png\n"
> > +	"  -i\tPrint buffer info\n"
> > +	"  -b\tDump to base64 (bb and images)\n"
> > +	;
> > +
> > +igt_main_args("dpib", NULL, help_str, opt_handler, NULL)
> > +{
> > +	int xe, i;
> > +	struct buf_ops *bops;
> > +	uint32_t width;
> > +
> > +	struct test {
> > +		uint32_t tiling;
> > +		const char *tiling_name;
> > +	} tests[] = {
> > +		{ I915_TILING_NONE, "none" },
> > +		{ I915_TILING_X, "x" },
> > +		{ I915_TILING_Y, "y" },
> > +	};
> > +
> > +	igt_fixture {
> > +		xe = drm_open_driver(DRIVER_XE);
> > +		bops = buf_ops_create(xe);
> > +		xe_device_get(xe);
> > +	}
> > +
> > +	igt_describe("Ensure reset is possible on fresh bb");
> > +	igt_subtest("reset-bb")
> > +		reset_bb(bops);
> > +
> > +	igt_subtest_f("purge-bb")
> > +		purge_bb(bops);
> > +
> > +	igt_subtest("simple-bb")
> > +		simple_bb(bops, false);
> > +
> > +	igt_subtest("simple-bb-ctx")
> > +		simple_bb(bops, true);
> > +
> > +	igt_subtest("bb-with-allocator")
> > +		bb_with_allocator(bops);
> > +
> > +	igt_subtest("lot-of-buffers")
> > +		lot_of_buffers(bops);
> > +
> > +	igt_subtest("add-remove-objects")
> > +		add_remove_objects(bops);
> > +
> > +	igt_subtest("destroy-bb")
> > +		destroy_bb(bops);
> > +
> > +	igt_subtest_with_dynamic("create-in-region") {
> > +		uint64_t memreg = all_memory_regions(xe), region;
> > +
> > +		xe_for_each_mem_region(fd, memreg, region)
> > +			igt_dynamic_f("region-%s", xe_region_name(region))
> > +				create_in_region(bops, region);
> > +	}
> > +
> > +	igt_subtest("blit-simple")
> > +		blit(bops, INTEL_ALLOCATOR_SIMPLE);
> > +
> > +	igt_subtest("blit-reloc")
> > +		blit(bops, INTEL_ALLOCATOR_RELOC);
> > +
> > +	igt_subtest("intel-bb-blit-none")
> > +		do_intel_bb_blit(bops, 3, I915_TILING_NONE);
> > +
> > +	igt_subtest("intel-bb-blit-x")
> > +		do_intel_bb_blit(bops, 3, I915_TILING_X);
> > +
> > +	igt_subtest("intel-bb-blit-y") {
> > +		igt_require(intel_gen(intel_get_drm_devid(xe)) >= 6);
> > +		do_intel_bb_blit(bops, 3, I915_TILING_Y);
> > +	}
> > +
> > +	igt_subtest("offset-control")
> > +		offset_control(bops);
> > +
> > +	igt_subtest("delta-check")
> > +		delta_check(bops);
> > +
> > +	igt_subtest("full-batch")
> > +		full_batch(bops);
> > +
> > +	igt_subtest_with_dynamic("render") {
> > +		for (i = 0; i < ARRAY_SIZE(tests); i++) {
> > +			const struct test *t = &tests[i];
> > +
> > +			for (width = 512; width <= 1024; width += 512)
> > +				igt_dynamic_f("render-%s-%u", t->tiling_name, width)
> > +					render(bops, t->tiling, width, width);
> > +		}
> > +	}
> > +
> > +	igt_fixture {
> > +		xe_device_put(xe);
> > +		buf_ops_destroy(bops);
> > +		close(xe);
> > +	}
> > +}
> > -- 
> > 2.34.1
> > 


More information about the igt-dev mailing list