[igt-dev] [PATCH 1/1] xe: Rename engine to exec_queue
Francois Dugast
francois.dugast at intel.com
Wed Aug 2 11:07:50 UTC 2023
Engine was inappropriately used to refer to execution queues and
it also created some confusion with hardware engines. Update to
the kernel header where this was fixed and also update variable
names in tests.
Signed-off-by: Francois Dugast <francois.dugast at intel.com>
---
include/drm-uapi/xe_drm.h | 104 +++++-----
lib/igt_fb.c | 4 +-
lib/intel_batchbuffer.c | 4 +-
lib/intel_ctx.c | 2 +-
lib/xe/xe_compute.c | 8 +-
lib/xe/xe_ioctl.c | 80 ++++----
lib/xe/xe_ioctl.h | 32 ++--
lib/xe/xe_spin.c | 24 +--
lib/xe/xe_spin.h | 2 +-
tests/intel-ci/xe-fast-feedback.testlist | 60 +++---
tests/xe/xe_ccs.c | 16 +-
tests/xe/xe_create.c | 60 +++---
tests/xe/xe_dma_buf_sync.c | 8 +-
tests/xe/xe_evict.c | 234 +++++++++++------------
tests/xe/xe_exec_balancer.c | 96 +++++-----
tests/xe/xe_exec_basic.c | 116 +++++------
tests/xe/xe_exec_compute_mode.c | 126 ++++++------
tests/xe/xe_exec_fault_mode.c | 176 ++++++++---------
tests/xe/xe_exec_reset.c | 214 ++++++++++-----------
tests/xe/xe_exec_store.c | 20 +-
tests/xe/xe_exec_threads.c | 172 ++++++++---------
tests/xe/xe_exercise_blt.c | 8 +-
tests/xe/xe_guc_pc.c | 46 ++---
tests/xe/xe_huc_copy.c | 8 +-
tests/xe/xe_intel_bb.c | 4 +-
tests/xe/xe_noexec_ping_pong.c | 16 +-
tests/xe/xe_pm.c | 34 ++--
tests/xe/xe_spin_batch.c | 20 +-
tests/xe/xe_vm.c | 214 ++++++++++-----------
29 files changed, 959 insertions(+), 949 deletions(-)
diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h
index 1ea453737..86f16d50e 100644
--- a/include/drm-uapi/xe_drm.h
+++ b/include/drm-uapi/xe_drm.h
@@ -3,8 +3,8 @@
* Copyright © 2023 Intel Corporation
*/
-#ifndef _XE_DRM_H_
-#define _XE_DRM_H_
+#ifndef _UAPI_XE_DRM_H_
+#define _UAPI_XE_DRM_H_
#include "drm.h"
@@ -16,6 +16,16 @@ extern "C" {
* subject to backwards-compatibility constraints.
*/
+/**
+ * DOC: uevent generated by xe on it's pci node.
+ *
+ * XE_RESET_FAILED_UEVENT - Event is generated when attempt to reset gt
+ * fails. The value supplied with the event is always "NEEDS_RESET".
+ * Additional information supplied is tile id and gt id of the gt unit for
+ * which reset has failed.
+ */
+#define XE_RESET_FAILED_UEVENT "DEVICE_STATUS"
+
/**
* struct xe_user_extension - Base class for defining a chain of extensions
*
@@ -29,7 +39,7 @@ extern "C" {
* redefine the interface more easily than an ever growing struct of
* increasing complexity, and for large parts of that interface to be
* entirely optional. The downside is more pointer chasing; chasing across
- * the boundary with pointers encapsulated inside u64.
+ * the __user boundary with pointers encapsulated inside u64.
*
* Example chaining:
*
@@ -93,14 +103,14 @@ struct xe_user_extension {
#define DRM_XE_VM_CREATE 0x03
#define DRM_XE_VM_DESTROY 0x04
#define DRM_XE_VM_BIND 0x05
-#define DRM_XE_ENGINE_CREATE 0x06
-#define DRM_XE_ENGINE_DESTROY 0x07
+#define DRM_XE_EXEC_QUEUE_CREATE 0x06
+#define DRM_XE_EXEC_QUEUE_DESTROY 0x07
#define DRM_XE_EXEC 0x08
#define DRM_XE_MMIO 0x09
-#define DRM_XE_ENGINE_SET_PROPERTY 0x0a
+#define DRM_XE_EXEC_QUEUE_SET_PROPERTY 0x0a
#define DRM_XE_WAIT_USER_FENCE 0x0b
#define DRM_XE_VM_MADVISE 0x0c
-#define DRM_XE_ENGINE_GET_PROPERTY 0x0d
+#define DRM_XE_EXEC_QUEUE_GET_PROPERTY 0x0d
/* Must be kept compact -- no holes */
#define DRM_IOCTL_XE_DEVICE_QUERY DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEVICE_QUERY, struct drm_xe_device_query)
@@ -109,12 +119,12 @@ struct xe_user_extension {
#define DRM_IOCTL_XE_VM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_VM_CREATE, struct drm_xe_vm_create)
#define DRM_IOCTL_XE_VM_DESTROY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_VM_DESTROY, struct drm_xe_vm_destroy)
#define DRM_IOCTL_XE_VM_BIND DRM_IOW(DRM_COMMAND_BASE + DRM_XE_VM_BIND, struct drm_xe_vm_bind)
-#define DRM_IOCTL_XE_ENGINE_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_ENGINE_CREATE, struct drm_xe_engine_create)
-#define DRM_IOCTL_XE_ENGINE_GET_PROPERTY DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_ENGINE_GET_PROPERTY, struct drm_xe_engine_get_property)
-#define DRM_IOCTL_XE_ENGINE_DESTROY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_ENGINE_DESTROY, struct drm_xe_engine_destroy)
+#define DRM_IOCTL_XE_EXEC_QUEUE_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_EXEC_QUEUE_CREATE, struct drm_xe_exec_queue_create)
+#define DRM_IOCTL_XE_EXEC_QUEUE_GET_PROPERTY DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_EXEC_QUEUE_GET_PROPERTY, struct drm_xe_exec_queue_get_property)
+#define DRM_IOCTL_XE_EXEC_QUEUE_DESTROY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC_QUEUE_DESTROY, struct drm_xe_exec_queue_destroy)
#define DRM_IOCTL_XE_EXEC DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)
#define DRM_IOCTL_XE_MMIO DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_MMIO, struct drm_xe_mmio)
-#define DRM_IOCTL_XE_ENGINE_SET_PROPERTY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_ENGINE_SET_PROPERTY, struct drm_xe_engine_set_property)
+#define DRM_IOCTL_XE_EXEC_QUEUE_SET_PROPERTY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC_QUEUE_SET_PROPERTY, struct drm_xe_exec_queue_set_property)
#define DRM_IOCTL_XE_WAIT_USER_FENCE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)
#define DRM_IOCTL_XE_VM_MADVISE DRM_IOW(DRM_COMMAND_BASE + DRM_XE_VM_MADVISE, struct drm_xe_vm_madvise)
@@ -639,11 +649,11 @@ struct drm_xe_vm_bind {
__u32 vm_id;
/**
- * @engine_id: engine_id, must be of class DRM_XE_ENGINE_CLASS_VM_BIND
- * and engine must have same vm_id. If zero, the default VM bind engine
+ * @exec_queue_id: exec_queue_id, must be of class DRM_XE_ENGINE_CLASS_VM_BIND
+ * and exec queue must have same vm_id. If zero, the default VM bind engine
* is used.
*/
- __u32 engine_id;
+ __u32 exec_queue_id;
/** @num_binds: number of binds in this IOCTL */
__u32 num_binds;
@@ -675,8 +685,8 @@ struct drm_xe_vm_bind {
__u64 reserved[2];
};
-/** struct drm_xe_ext_engine_set_property - engine set property extension */
-struct drm_xe_ext_engine_set_property {
+/** struct drm_xe_ext_exec_queue_set_property - exec queue set property extension */
+struct drm_xe_ext_exec_queue_set_property {
/** @base: base user extension */
struct xe_user_extension base;
@@ -691,32 +701,32 @@ struct drm_xe_ext_engine_set_property {
};
/**
- * struct drm_xe_engine_set_property - engine set property
+ * struct drm_xe_exec_queue_set_property - exec queue set property
*
- * Same namespace for extensions as drm_xe_engine_create
+ * Same namespace for extensions as drm_xe_exec_queue_create
*/
-struct drm_xe_engine_set_property {
+struct drm_xe_exec_queue_set_property {
/** @extensions: Pointer to the first extension struct, if any */
__u64 extensions;
- /** @engine_id: Engine ID */
- __u32 engine_id;
+ /** @exec_queue_id: Exec queue ID */
+ __u32 exec_queue_id;
-#define XE_ENGINE_SET_PROPERTY_PRIORITY 0
-#define XE_ENGINE_SET_PROPERTY_TIMESLICE 1
-#define XE_ENGINE_SET_PROPERTY_PREEMPTION_TIMEOUT 2
+#define XE_EXEC_QUEUE_SET_PROPERTY_PRIORITY 0
+#define XE_EXEC_QUEUE_SET_PROPERTY_TIMESLICE 1
+#define XE_EXEC_QUEUE_SET_PROPERTY_PREEMPTION_TIMEOUT 2
/*
* Long running or ULLS engine mode. DMA fences not allowed in this
* mode. Must match the value of DRM_XE_VM_CREATE_COMPUTE_MODE, serves
* as a sanity check the UMD knows what it is doing. Can only be set at
* engine create time.
*/
-#define XE_ENGINE_SET_PROPERTY_COMPUTE_MODE 3
-#define XE_ENGINE_SET_PROPERTY_PERSISTENCE 4
-#define XE_ENGINE_SET_PROPERTY_JOB_TIMEOUT 5
-#define XE_ENGINE_SET_PROPERTY_ACC_TRIGGER 6
-#define XE_ENGINE_SET_PROPERTY_ACC_NOTIFY 7
-#define XE_ENGINE_SET_PROPERTY_ACC_GRANULARITY 8
+#define XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE 3
+#define XE_EXEC_QUEUE_SET_PROPERTY_PERSISTENCE 4
+#define XE_EXEC_QUEUE_SET_PROPERTY_JOB_TIMEOUT 5
+#define XE_EXEC_QUEUE_SET_PROPERTY_ACC_TRIGGER 6
+#define XE_EXEC_QUEUE_SET_PROPERTY_ACC_NOTIFY 7
+#define XE_EXEC_QUEUE_SET_PROPERTY_ACC_GRANULARITY 8
/** @property: property to set */
__u32 property;
@@ -745,25 +755,25 @@ struct drm_xe_engine_class_instance {
__u16 gt_id;
};
-struct drm_xe_engine_create {
-#define XE_ENGINE_EXTENSION_SET_PROPERTY 0
+struct drm_xe_exec_queue_create {
+#define XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY 0
/** @extensions: Pointer to the first extension struct, if any */
__u64 extensions;
- /** @width: submission width (number BB per exec) for this engine */
+ /** @width: submission width (number BB per exec) for this exec queue */
__u16 width;
- /** @num_placements: number of valid placements for this engine */
+ /** @num_placements: number of valid placements for this exec queue */
__u16 num_placements;
- /** @vm_id: VM to use for this engine */
+ /** @vm_id: VM to use for this exec queue */
__u32 vm_id;
/** @flags: MBZ */
__u32 flags;
- /** @engine_id: Returned engine ID */
- __u32 engine_id;
+ /** @exec_queue_id: Returned exec queue ID */
+ __u32 exec_queue_id;
/**
* @instances: user pointer to a 2-d array of struct
@@ -778,14 +788,14 @@ struct drm_xe_engine_create {
__u64 reserved[2];
};
-struct drm_xe_engine_get_property {
+struct drm_xe_exec_queue_get_property {
/** @extensions: Pointer to the first extension struct, if any */
__u64 extensions;
- /** @engine_id: Engine ID */
- __u32 engine_id;
+ /** @exec_queue_id: Exec queue ID */
+ __u32 exec_queue_id;
-#define XE_ENGINE_GET_PROPERTY_BAN 0
+#define XE_EXEC_QUEUE_GET_PROPERTY_BAN 0
/** @property: property to get */
__u32 property;
@@ -796,9 +806,9 @@ struct drm_xe_engine_get_property {
__u64 reserved[2];
};
-struct drm_xe_engine_destroy {
- /** @engine_id: Engine ID */
- __u32 engine_id;
+struct drm_xe_exec_queue_destroy {
+ /** @exec_queue_id: Exec queue ID */
+ __u32 exec_queue_id;
/** @pad: MBZ */
__u32 pad;
@@ -845,8 +855,8 @@ struct drm_xe_exec {
/** @extensions: Pointer to the first extension struct, if any */
__u64 extensions;
- /** @engine_id: Engine ID for the batch buffer */
- __u32 engine_id;
+ /** @exec_queue_id: Exec queue ID for the batch buffer */
+ __u32 exec_queue_id;
/** @num_syncs: Amount of struct drm_xe_sync in array. */
__u32 num_syncs;
@@ -1050,4 +1060,4 @@ struct drm_xe_vm_madvise {
}
#endif
-#endif /* _XE_DRM_H_ */
+#endif /* _UAPI_XE_DRM_H_ */
diff --git a/lib/igt_fb.c b/lib/igt_fb.c
index b33c639ab..8f5e3db9f 100644
--- a/lib/igt_fb.c
+++ b/lib/igt_fb.c
@@ -2881,7 +2881,7 @@ static void blitcopy(const struct igt_fb *dst_fb,
mem_region) == 0);
} else if (is_xe) {
vm = xe_vm_create(dst_fb->fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engine = xe_engine_create(dst_fb->fd, vm, &inst, 0);
+ engine = xe_exec_queue_create(dst_fb->fd, vm, &inst, 0);
xe_ctx = intel_ctx_xe(dst_fb->fd, vm, engine, 0, 0, 0);
mem_region = vram_if_possible(dst_fb->fd, 0);
@@ -3007,7 +3007,7 @@ static void blitcopy(const struct igt_fb *dst_fb,
if(is_xe) {
gem_close(dst_fb->fd, xe_bb);
- xe_engine_destroy(dst_fb->fd, engine);
+ xe_exec_queue_destroy(dst_fb->fd, engine);
xe_vm_destroy(dst_fb->fd, vm);
free(xe_ctx);
}
diff --git a/lib/intel_batchbuffer.c b/lib/intel_batchbuffer.c
index 163d39d6b..682c0fe1d 100644
--- a/lib/intel_batchbuffer.c
+++ b/lib/intel_batchbuffer.c
@@ -2337,10 +2337,10 @@ __xe_bb_exec(struct intel_bb *ibb, uint64_t flags, bool sync)
igt_debug("Run on %s\n", xe_engine_class_string(inst.engine_class));
if (ibb->engine_id)
- xe_engine_destroy(ibb->fd, ibb->engine_id);
+ xe_exec_queue_destroy(ibb->fd, ibb->engine_id);
ibb->engine_id = engine_id =
- xe_engine_create(ibb->fd, ibb->vm_id, &inst, 0);
+ xe_exec_queue_create(ibb->fd, ibb->vm_id, &inst, 0);
} else {
engine_id = ibb->engine_id;
}
diff --git a/lib/intel_ctx.c b/lib/intel_ctx.c
index 0c1ce6d10..364ede76f 100644
--- a/lib/intel_ctx.c
+++ b/lib/intel_ctx.c
@@ -427,7 +427,7 @@ int __intel_ctx_xe_exec(const intel_ctx_t *ctx, uint64_t ahnd, uint64_t bb_offse
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
};
struct drm_xe_exec exec = {
- .engine_id = ctx->engine,
+ .exec_queue_id = ctx->engine,
.syncs = (uintptr_t)syncs,
.num_syncs = 2,
.address = bb_offset,
diff --git a/lib/xe/xe_compute.c b/lib/xe/xe_compute.c
index 2a3686a1b..3e8112a04 100644
--- a/lib/xe/xe_compute.c
+++ b/lib/xe/xe_compute.c
@@ -389,7 +389,7 @@ static void tgllp_compute_exec_compute(uint32_t *addr_bo_buffer_batch,
static void tgl_compute_exec(int fd, const unsigned char *kernel,
unsigned int size)
{
- uint32_t vm, engine;
+ uint32_t vm, exec_queue;
float *dinput;
struct drm_xe_sync sync = { 0 };
#define TGL_BO_DICT_ENTRIES 7
@@ -407,7 +407,7 @@ static void tgl_compute_exec(int fd, const unsigned char *kernel,
bo_dict[0].size = ALIGN(size, 0x1000);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engine = xe_engine_create_class(fd, vm, DRM_XE_ENGINE_CLASS_RENDER);
+ exec_queue = xe_exec_queue_create_class(fd, vm, DRM_XE_ENGINE_CLASS_RENDER);
sync.flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL;
sync.handle = syncobj_create(fd, 0);
@@ -429,7 +429,7 @@ static void tgl_compute_exec(int fd, const unsigned char *kernel,
tgllp_compute_exec_compute(bo_dict[6].data, ADDR_SURFACE_STATE_BASE, ADDR_DYNAMIC_STATE_BASE, ADDR_INDIRECT_OBJECT_BASE, OFFSET_INDIRECT_DATA_START);
- xe_exec_wait(fd, engine, ADDR_BATCH);
+ xe_exec_wait(fd, exec_queue, ADDR_BATCH);
for (int i = 0; i < SIZE_DATA; i++)
igt_assert(((float *)bo_dict[5].data)[i] == ((float *)bo_dict[4].data)[i] * ((float *) bo_dict[4].data)[i]);
@@ -441,7 +441,7 @@ static void tgl_compute_exec(int fd, const unsigned char *kernel,
}
syncobj_destroy(fd, sync.handle);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
xe_vm_destroy(fd, vm);
}
diff --git a/lib/xe/xe_ioctl.c b/lib/xe/xe_ioctl.c
index a1799e09f..730dcfd16 100644
--- a/lib/xe/xe_ioctl.c
+++ b/lib/xe/xe_ioctl.c
@@ -62,16 +62,16 @@ uint32_t xe_vm_create(int fd, uint32_t flags, uint64_t ext)
return create.vm_id;
}
-void xe_vm_unbind_all_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_unbind_all_async(int fd, uint32_t vm, uint32_t exec_queue,
uint32_t bo, struct drm_xe_sync *sync,
uint32_t num_syncs)
{
- __xe_vm_bind_assert(fd, vm, engine, bo, 0, 0, 0,
+ __xe_vm_bind_assert(fd, vm, exec_queue, bo, 0, 0, 0,
XE_VM_BIND_OP_UNMAP_ALL | XE_VM_BIND_FLAG_ASYNC,
sync, num_syncs, 0, 0);
}
-void xe_vm_bind_array(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_bind_array(int fd, uint32_t vm, uint32_t exec_queue,
struct drm_xe_vm_bind_op *bind_ops,
uint32_t num_bind, struct drm_xe_sync *sync,
uint32_t num_syncs)
@@ -82,14 +82,14 @@ void xe_vm_bind_array(int fd, uint32_t vm, uint32_t engine,
.vector_of_binds = (uintptr_t)bind_ops,
.num_syncs = num_syncs,
.syncs = (uintptr_t)sync,
- .engine_id = engine,
+ .exec_queue_id = exec_queue,
};
igt_assert(num_bind > 1);
igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_VM_BIND, &bind), 0);
}
-int __xe_vm_bind(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+int __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
struct drm_xe_sync *sync, uint32_t num_syncs, uint32_t region,
uint64_t ext)
@@ -106,7 +106,7 @@ int __xe_vm_bind(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
.bind.region = region,
.num_syncs = num_syncs,
.syncs = (uintptr_t)sync,
- .engine_id = engine,
+ .exec_queue_id = exec_queue,
};
if (igt_ioctl(fd, DRM_IOCTL_XE_VM_BIND, &bind))
@@ -115,12 +115,12 @@ int __xe_vm_bind(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
return 0;
}
-void __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+void __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size,
uint32_t op, struct drm_xe_sync *sync,
uint32_t num_syncs, uint32_t region, uint64_t ext)
{
- igt_assert_eq(__xe_vm_bind(fd, vm, engine, bo, offset, addr, size,
+ igt_assert_eq(__xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
op, sync, num_syncs, region, ext), 0);
}
@@ -140,59 +140,59 @@ void xe_vm_unbind(int fd, uint32_t vm, uint64_t offset,
XE_VM_BIND_OP_UNMAP, sync, num_syncs, 0, 0);
}
-void xe_vm_prefetch_async(int fd, uint32_t vm, uint32_t engine, uint64_t offset,
+void xe_vm_prefetch_async(int fd, uint32_t vm, uint32_t exec_queue, uint64_t offset,
uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs,
uint32_t region)
{
- __xe_vm_bind_assert(fd, vm, engine, 0, offset, addr, size,
+ __xe_vm_bind_assert(fd, vm, exec_queue, 0, offset, addr, size,
XE_VM_BIND_OP_PREFETCH | XE_VM_BIND_FLAG_ASYNC,
sync, num_syncs, region, 0);
}
-void xe_vm_bind_async(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+void xe_vm_bind_async(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs)
{
- __xe_vm_bind_assert(fd, vm, engine, bo, offset, addr, size,
+ __xe_vm_bind_assert(fd, vm, exec_queue, bo, offset, addr, size,
XE_VM_BIND_OP_MAP | XE_VM_BIND_FLAG_ASYNC, sync,
num_syncs, 0, 0);
}
-void xe_vm_bind_async_flags(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+void xe_vm_bind_async_flags(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs,
uint32_t flags)
{
- __xe_vm_bind_assert(fd, vm, engine, bo, offset, addr, size,
+ __xe_vm_bind_assert(fd, vm, exec_queue, bo, offset, addr, size,
XE_VM_BIND_OP_MAP | XE_VM_BIND_FLAG_ASYNC | flags,
sync, num_syncs, 0, 0);
}
-void xe_vm_bind_userptr_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_bind_userptr_async(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t userptr, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs)
{
- __xe_vm_bind_assert(fd, vm, engine, 0, userptr, addr, size,
+ __xe_vm_bind_assert(fd, vm, exec_queue, 0, userptr, addr, size,
XE_VM_BIND_OP_MAP_USERPTR | XE_VM_BIND_FLAG_ASYNC,
sync, num_syncs, 0, 0);
}
-void xe_vm_bind_userptr_async_flags(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_bind_userptr_async_flags(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t userptr, uint64_t addr,
uint64_t size, struct drm_xe_sync *sync,
uint32_t num_syncs, uint32_t flags)
{
- __xe_vm_bind_assert(fd, vm, engine, 0, userptr, addr, size,
+ __xe_vm_bind_assert(fd, vm, exec_queue, 0, userptr, addr, size,
XE_VM_BIND_OP_MAP_USERPTR | XE_VM_BIND_FLAG_ASYNC |
flags, sync, num_syncs, 0, 0);
}
-void xe_vm_unbind_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_unbind_async(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs)
{
- __xe_vm_bind_assert(fd, vm, engine, 0, offset, addr, size,
+ __xe_vm_bind_assert(fd, vm, exec_queue, 0, offset, addr, size,
XE_VM_BIND_OP_UNMAP | XE_VM_BIND_FLAG_ASYNC, sync,
num_syncs, 0, 0);
}
@@ -275,12 +275,12 @@ uint32_t xe_bo_create(int fd, int gt, uint32_t vm, uint64_t size)
return create.handle;
}
-uint32_t xe_bind_engine_create(int fd, uint32_t vm, uint64_t ext)
+uint32_t xe_bind_exec_queue_create(int fd, uint32_t vm, uint64_t ext)
{
struct drm_xe_engine_class_instance instance = {
.engine_class = DRM_XE_ENGINE_CLASS_VM_BIND,
};
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.extensions = ext,
.vm_id = vm,
.width = 1,
@@ -288,16 +288,16 @@ uint32_t xe_bind_engine_create(int fd, uint32_t vm, uint64_t ext)
.instances = to_user_pointer(&instance),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE, &create), 0);
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, &create), 0);
- return create.engine_id;
+ return create.exec_queue_id;
}
-uint32_t xe_engine_create(int fd, uint32_t vm,
+uint32_t xe_exec_queue_create(int fd, uint32_t vm,
struct drm_xe_engine_class_instance *instance,
uint64_t ext)
{
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.extensions = ext,
.vm_id = vm,
.width = 1,
@@ -305,37 +305,37 @@ uint32_t xe_engine_create(int fd, uint32_t vm,
.instances = to_user_pointer(instance),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE, &create), 0);
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, &create), 0);
- return create.engine_id;
+ return create.exec_queue_id;
}
-uint32_t xe_engine_create_class(int fd, uint32_t vm, uint16_t class)
+uint32_t xe_exec_queue_create_class(int fd, uint32_t vm, uint16_t class)
{
struct drm_xe_engine_class_instance instance = {
.engine_class = class,
.engine_instance = 0,
.gt_id = 0,
};
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = 1,
.num_placements = 1,
.instances = to_user_pointer(&instance),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE, &create), 0);
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, &create), 0);
- return create.engine_id;
+ return create.exec_queue_id;
}
-void xe_engine_destroy(int fd, uint32_t engine)
+void xe_exec_queue_destroy(int fd, uint32_t exec_queue)
{
- struct drm_xe_engine_destroy destroy = {
- .engine_id = engine,
+ struct drm_xe_exec_queue_destroy destroy = {
+ .exec_queue_id = exec_queue,
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_DESTROY, &destroy), 0);
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
}
uint64_t xe_bo_mmap_offset(int fd, uint32_t bo)
@@ -388,11 +388,11 @@ void xe_exec(int fd, struct drm_xe_exec *exec)
igt_assert_eq(__xe_exec(fd, exec), 0);
}
-void xe_exec_sync(int fd, uint32_t engine, uint64_t addr,
+void xe_exec_sync(int fd, uint32_t exec_queue, uint64_t addr,
struct drm_xe_sync *sync, uint32_t num_syncs)
{
struct drm_xe_exec exec = {
- .engine_id = engine,
+ .exec_queue_id = exec_queue,
.syncs = (uintptr_t)sync,
.num_syncs = num_syncs,
.address = addr,
@@ -402,14 +402,14 @@ void xe_exec_sync(int fd, uint32_t engine, uint64_t addr,
igt_assert_eq(__xe_exec(fd, &exec), 0);
}
-void xe_exec_wait(int fd, uint32_t engine, uint64_t addr)
+void xe_exec_wait(int fd, uint32_t exec_queue, uint64_t addr)
{
struct drm_xe_sync sync = {
.flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL,
.handle = syncobj_create(fd, 0),
};
- xe_exec_sync(fd, engine, addr, &sync, 1);
+ xe_exec_sync(fd, exec_queue, addr, &sync, 1);
igt_assert(syncobj_wait(fd, &sync.handle, 1, INT64_MAX, 0, NULL));
syncobj_destroy(fd, sync.handle);
diff --git a/lib/xe/xe_ioctl.h b/lib/xe/xe_ioctl.h
index f9c3acb4a..6c281b3bf 100644
--- a/lib/xe/xe_ioctl.h
+++ b/lib/xe/xe_ioctl.h
@@ -17,11 +17,11 @@
uint32_t xe_cs_prefetch_size(int fd);
uint32_t xe_vm_create(int fd, uint32_t flags, uint64_t ext);
-int __xe_vm_bind(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+int __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
struct drm_xe_sync *sync, uint32_t num_syncs, uint32_t region,
uint64_t ext);
-void __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+void __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size,
uint32_t op, struct drm_xe_sync *sync,
uint32_t num_syncs, uint32_t region, uint64_t ext);
@@ -31,36 +31,36 @@ void xe_vm_bind(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
void xe_vm_unbind(int fd, uint32_t vm, uint64_t offset,
uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs);
-void xe_vm_prefetch_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_prefetch_async(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs,
uint32_t region);
-void xe_vm_bind_async(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+void xe_vm_bind_async(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs);
-void xe_vm_bind_userptr_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_bind_userptr_async(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t userptr, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs);
-void xe_vm_bind_async_flags(int fd, uint32_t vm, uint32_t engine, uint32_t bo,
+void xe_vm_bind_async_flags(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs,
uint32_t flags);
-void xe_vm_bind_userptr_async_flags(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_bind_userptr_async_flags(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t userptr, uint64_t addr,
uint64_t size, struct drm_xe_sync *sync,
uint32_t num_syncs, uint32_t flags);
-void xe_vm_unbind_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_unbind_async(int fd, uint32_t vm, uint32_t exec_queue,
uint64_t offset, uint64_t addr, uint64_t size,
struct drm_xe_sync *sync, uint32_t num_syncs);
void xe_vm_bind_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
uint64_t addr, uint64_t size);
void xe_vm_unbind_sync(int fd, uint32_t vm, uint64_t offset,
uint64_t addr, uint64_t size);
-void xe_vm_bind_array(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_bind_array(int fd, uint32_t vm, uint32_t exec_queue,
struct drm_xe_vm_bind_op *bind_ops,
uint32_t num_bind, struct drm_xe_sync *sync,
uint32_t num_syncs);
-void xe_vm_unbind_all_async(int fd, uint32_t vm, uint32_t engine,
+void xe_vm_unbind_all_async(int fd, uint32_t vm, uint32_t exec_queue,
uint32_t bo, struct drm_xe_sync *sync,
uint32_t num_syncs);
void xe_vm_destroy(int fd, uint32_t vm);
@@ -68,20 +68,20 @@ uint32_t __xe_bo_create_flags(int fd, uint32_t vm, uint64_t size, uint32_t flags
uint32_t *handle);
uint32_t xe_bo_create_flags(int fd, uint32_t vm, uint64_t size, uint32_t flags);
uint32_t xe_bo_create(int fd, int gt, uint32_t vm, uint64_t size);
-uint32_t xe_engine_create(int fd, uint32_t vm,
+uint32_t xe_exec_queue_create(int fd, uint32_t vm,
struct drm_xe_engine_class_instance *instance,
uint64_t ext);
-uint32_t xe_bind_engine_create(int fd, uint32_t vm, uint64_t ext);
-uint32_t xe_engine_create_class(int fd, uint32_t vm, uint16_t class);
-void xe_engine_destroy(int fd, uint32_t engine);
+uint32_t xe_bind_exec_queue_create(int fd, uint32_t vm, uint64_t ext);
+uint32_t xe_exec_queue_create_class(int fd, uint32_t vm, uint16_t class);
+void xe_exec_queue_destroy(int fd, uint32_t exec_queue);
uint64_t xe_bo_mmap_offset(int fd, uint32_t bo);
void *xe_bo_map(int fd, uint32_t bo, size_t size);
void *xe_bo_mmap_ext(int fd, uint32_t bo, size_t size, int prot);
int __xe_exec(int fd, struct drm_xe_exec *exec);
void xe_exec(int fd, struct drm_xe_exec *exec);
-void xe_exec_sync(int fd, uint32_t engine, uint64_t addr,
+void xe_exec_sync(int fd, uint32_t exec_queue, uint64_t addr,
struct drm_xe_sync *sync, uint32_t num_syncs);
-void xe_exec_wait(int fd, uint32_t engine, uint64_t addr);
+void xe_exec_wait(int fd, uint32_t exec_queue, uint64_t addr);
int64_t xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
struct drm_xe_engine_class_instance *eci,
int64_t timeout);
diff --git a/lib/xe/xe_spin.c b/lib/xe/xe_spin.c
index e799fcfc5..cd9c1a7d3 100644
--- a/lib/xe/xe_spin.c
+++ b/lib/xe/xe_spin.c
@@ -84,7 +84,7 @@ void xe_spin_end(struct xe_spin *spin)
/**
* xe_spin_create:
- *@opt: controlling options such as allocator handle, engine, vm etc
+ *@opt: controlling options such as allocator handle, exec_queue, vm etc
*
* igt_spin_new for xe, xe_spin_create submits a batch using xe_spin_init
* which wraps around vm bind and unbinding the object associated to it.
@@ -121,9 +121,9 @@ xe_spin_create(int fd, const struct igt_spin_factory *opt)
if (!spin->engine) {
if (opt->hwe)
- spin->engine = xe_engine_create(fd, spin->vm, opt->hwe, 0);
+ spin->engine = xe_exec_queue_create(fd, spin->vm, opt->hwe, 0);
else
- spin->engine = xe_engine_create_class(fd, spin->vm, DRM_XE_ENGINE_CLASS_COPY);
+ spin->engine = xe_exec_queue_create_class(fd, spin->vm, DRM_XE_ENGINE_CLASS_COPY);
}
spin->handle = xe_bo_create_flags(fd, spin->vm, bo_size,
@@ -137,7 +137,7 @@ xe_spin_create(int fd, const struct igt_spin_factory *opt)
else
xe_spin_init(xe_spin, addr, false);
- exec.engine_id = spin->engine;
+ exec.exec_queue_id = spin->engine;
exec.address = addr;
sync.handle = spin->syncobj;
igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec), 0);
@@ -161,8 +161,8 @@ void xe_spin_sync_wait(int fd, struct igt_spin *spin)
*@spin: spin state from igt_spin_new()
*
* Wrapper to free spinner whhich is triggered by xe_spin_create.
- * which distroys vm, engine and unbinds the vm which is binded to
- * the engine and bo.
+ * which distroys vm, exec_queue and unbinds the vm which is binded to
+ * the exec_queue and bo.
*
*/
void xe_spin_free(int fd, struct igt_spin *spin)
@@ -176,7 +176,7 @@ void xe_spin_free(int fd, struct igt_spin *spin)
gem_close(fd, spin->handle);
if (!spin->opts.engine)
- xe_engine_destroy(fd, spin->engine);
+ xe_exec_queue_destroy(fd, spin->engine);
if (!spin->opts.vm)
xe_vm_destroy(fd, spin->vm);
@@ -189,7 +189,7 @@ void xe_cork_init(int fd, struct drm_xe_engine_class_instance *hwe,
{
uint64_t addr = xe_get_default_alignment(fd);
size_t bo_size = xe_get_default_alignment(fd);
- uint32_t vm, bo, engine, syncobj;
+ uint32_t vm, bo, exec_queue, syncobj;
struct xe_spin *spin;
struct drm_xe_sync sync = {
.flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL,
@@ -208,11 +208,11 @@ void xe_cork_init(int fd, struct drm_xe_engine_class_instance *hwe,
xe_vm_bind_sync(fd, vm, bo, 0, addr, bo_size);
- engine = xe_engine_create(fd, vm, hwe, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
syncobj = syncobj_create(fd, 0);
xe_spin_init(spin, addr, true);
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = addr;
sync.handle = syncobj;
igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec), 0);
@@ -221,7 +221,7 @@ void xe_cork_init(int fd, struct drm_xe_engine_class_instance *hwe,
cork->fd = fd;
cork->vm = vm;
cork->bo = bo;
- cork->engine = engine;
+ cork->exec_queue = exec_queue;
cork->syncobj = syncobj;
}
@@ -249,7 +249,7 @@ void xe_cork_wait_done(struct xe_cork *cork)
void xe_cork_fini(struct xe_cork *cork)
{
syncobj_destroy(cork->fd, cork->syncobj);
- xe_engine_destroy(cork->fd, cork->engine);
+ xe_exec_queue_destroy(cork->fd, cork->exec_queue);
xe_vm_destroy(cork->fd, cork->vm);
gem_close(cork->fd, cork->bo);
}
diff --git a/lib/xe/xe_spin.h b/lib/xe/xe_spin.h
index 54a52b403..c84db175d 100644
--- a/lib/xe/xe_spin.h
+++ b/lib/xe/xe_spin.h
@@ -35,7 +35,7 @@ struct xe_cork {
int fd;
uint32_t vm;
uint32_t bo;
- uint32_t engine;
+ uint32_t exec_queue;
uint32_t syncobj;
};
diff --git a/tests/intel-ci/xe-fast-feedback.testlist b/tests/intel-ci/xe-fast-feedback.testlist
index 2799d9cfb..78814f650 100644
--- a/tests/intel-ci/xe-fast-feedback.testlist
+++ b/tests/intel-ci/xe-fast-feedback.testlist
@@ -2,8 +2,8 @@
igt at xe_module_load@load
igt at xe_compute@compute-square
-igt at xe_create@create-engines-noleak
-igt at xe_create@create-engines-leak
+igt at xe_create@create-execqueues-noleak
+igt at xe_create@create-execqueues-leak
igt at xe_create@create-massive-size
igt at xe_debugfs@base
igt at xe_debugfs@gt
@@ -53,54 +53,54 @@ igt at xe_exec_basic@twice-rebind
igt at xe_exec_basic@twice-userptr-rebind
igt at xe_exec_basic@twice-userptr-invalidate
igt at xe_exec_basic@no-exec-userptr-invalidate
-igt at xe_exec_basic@twice-bindengine
-igt at xe_exec_basic@no-exec-bindengine
-igt at xe_exec_basic@twice-bindengine-userptr
-igt at xe_exec_basic@twice-bindengine-rebind
-igt at xe_exec_basic@twice-bindengine-userptr-rebind
-igt at xe_exec_basic@twice-bindengine-userptr-invalidate
+igt at xe_exec_basic@twice-bindexecqueue
+igt at xe_exec_basic@no-exec-bindexecqueue
+igt at xe_exec_basic@twice-bindexecqueue-userptr
+igt at xe_exec_basic@twice-bindexecqueue-rebind
+igt at xe_exec_basic@twice-bindexecqueue-userptr-rebind
+igt at xe_exec_basic@twice-bindexecqueue-userptr-invalidate
igt at xe_exec_compute_mode@twice-basic
igt at xe_exec_compute_mode@twice-preempt-fence-early
igt at xe_exec_compute_mode@twice-userptr
igt at xe_exec_compute_mode@twice-rebind
igt at xe_exec_compute_mode@twice-userptr-rebind
igt at xe_exec_compute_mode@twice-userptr-invalidate
-igt at xe_exec_compute_mode@twice-bindengine
-igt at xe_exec_compute_mode@twice-bindengine-userptr
-igt at xe_exec_compute_mode@twice-bindengine-rebind
-igt at xe_exec_compute_mode@twice-bindengine-userptr-rebind
-igt at xe_exec_compute_mode@twice-bindengine-userptr-invalidate
+igt at xe_exec_compute_mode@twice-bindexecqueue
+igt at xe_exec_compute_mode@twice-bindexecqueue-userptr
+igt at xe_exec_compute_mode@twice-bindexecqueue-rebind
+igt at xe_exec_compute_mode@twice-bindexecqueue-userptr-rebind
+igt at xe_exec_compute_mode@twice-bindexecqueue-userptr-invalidate
igt at xe_exec_fault_mode@twice-basic
igt at xe_exec_fault_mode@many-basic
igt at xe_exec_fault_mode@twice-userptr
igt at xe_exec_fault_mode@twice-rebind
igt at xe_exec_fault_mode@twice-userptr-rebind
igt at xe_exec_fault_mode@twice-userptr-invalidate
-igt at xe_exec_fault_mode@twice-bindengine
-igt at xe_exec_fault_mode@twice-bindengine-userptr
-igt at xe_exec_fault_mode@twice-bindengine-rebind
-igt at xe_exec_fault_mode@twice-bindengine-userptr-rebind
-igt at xe_exec_fault_mode@twice-bindengine-userptr-invalidate
+igt at xe_exec_fault_mode@twice-bindexecqueue
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr
+igt at xe_exec_fault_mode@twice-bindexecqueue-rebind
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-rebind
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-invalidate
igt at xe_exec_fault_mode@twice-basic-imm
igt at xe_exec_fault_mode@twice-userptr-imm
igt at xe_exec_fault_mode@twice-rebind-imm
igt at xe_exec_fault_mode@twice-userptr-rebind-imm
igt at xe_exec_fault_mode@twice-userptr-invalidate-imm
-igt at xe_exec_fault_mode@twice-bindengine-imm
-igt at xe_exec_fault_mode@twice-bindengine-userptr-imm
-igt at xe_exec_fault_mode@twice-bindengine-rebind-imm
-igt at xe_exec_fault_mode@twice-bindengine-userptr-rebind-imm
-igt at xe_exec_fault_mode@twice-bindengine-userptr-invalidate-imm
+igt at xe_exec_fault_mode@twice-bindexecqueue-imm
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-imm
+igt at xe_exec_fault_mode@twice-bindexecqueue-rebind-imm
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-rebind-imm
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-invalidate-imm
igt at xe_exec_fault_mode@twice-basic-prefetch
igt at xe_exec_fault_mode@twice-userptr-prefetch
igt at xe_exec_fault_mode@twice-rebind-prefetch
igt at xe_exec_fault_mode@twice-userptr-rebind-prefetch
igt at xe_exec_fault_mode@twice-userptr-invalidate-prefetch
-igt at xe_exec_fault_mode@twice-bindengine-prefetch
-igt at xe_exec_fault_mode@twice-bindengine-userptr-prefetch
-igt at xe_exec_fault_mode@twice-bindengine-rebind-prefetch
-igt at xe_exec_fault_mode@twice-bindengine-userptr-rebind-prefetch
-igt at xe_exec_fault_mode@twice-bindengine-userptr-invalidate-prefetch
+igt at xe_exec_fault_mode@twice-bindexecqueue-prefetch
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-prefetch
+igt at xe_exec_fault_mode@twice-bindexecqueue-rebind-prefetch
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-rebind-prefetch
+igt at xe_exec_fault_mode@twice-bindexecqueue-userptr-invalidate-prefetch
igt at xe_exec_fault_mode@twice-invalid-fault
igt at xe_exec_fault_mode@twice-invalid-userptr-fault
igt at xe_exec_reset@close-fd-no-exec
@@ -153,7 +153,7 @@ igt at xe_pm_residency@gt-c6-on-idle
igt at xe_prime_self_import@basic-with_one_bo
igt at xe_prime_self_import@basic-with_fd_dup
#igt at xe_prime_self_import@basic-llseek-size
-igt at xe_query@query-engines
+igt at xe_query@query-execqueues
igt at xe_query@query-mem-usage
igt at xe_query@query-gts
igt at xe_query@query-config
@@ -170,7 +170,7 @@ igt at xe_vm@shared-pte-page
igt at xe_vm@shared-pde-page
igt at xe_vm@shared-pde2-page
igt at xe_vm@shared-pde3-page
-igt at xe_vm@bind-engines-independent
+igt at xe_vm@bind-execqueues-independent
igt at xe_vm@munmap-style-unbind-one-partial
igt at xe_vm@munmap-style-unbind-end
igt at xe_vm@munmap-style-unbind-front
diff --git a/tests/xe/xe_ccs.c b/tests/xe/xe_ccs.c
index 2d5ae33fa..1dbfccf6b 100644
--- a/tests/xe/xe_ccs.c
+++ b/tests/xe/xe_ccs.c
@@ -337,12 +337,12 @@ static void block_copy(int xe,
};
intel_ctx_t *surf_ctx = ctx;
uint64_t surf_ahnd = ahnd;
- uint32_t vm, engine;
+ uint32_t vm, exec_queue;
if (config->new_ctx) {
vm = xe_vm_create(xe, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engine = xe_engine_create(xe, vm, &inst, 0);
- surf_ctx = intel_ctx_xe(xe, vm, engine, 0, 0, 0);
+ exec_queue = xe_exec_queue_create(xe, vm, &inst, 0);
+ surf_ctx = intel_ctx_xe(xe, vm, exec_queue, 0, 0, 0);
surf_ahnd = intel_allocator_open(xe, surf_ctx->vm,
INTEL_ALLOCATOR_RELOC);
}
@@ -350,7 +350,7 @@ static void block_copy(int xe,
config->suspend_resume);
if (surf_ctx != ctx) {
- xe_engine_destroy(xe, engine);
+ xe_exec_queue_destroy(xe, exec_queue);
xe_vm_destroy(xe, vm);
free(surf_ctx);
put_ahnd(surf_ahnd);
@@ -512,7 +512,7 @@ static void block_copy_test(int xe,
};
intel_ctx_t *ctx;
struct igt_collection *regions;
- uint32_t vm, engine;
+ uint32_t vm, exec_queue;
int tiling;
if (config->compression && !blt_block_copy_supports_compression(xe))
@@ -548,17 +548,17 @@ static void block_copy_test(int xe,
uint32_t sync_bind, sync_out;
vm = xe_vm_create(xe, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engine = xe_engine_create(xe, vm, &inst, 0);
+ exec_queue = xe_exec_queue_create(xe, vm, &inst, 0);
sync_bind = syncobj_create(xe, 0);
sync_out = syncobj_create(xe, 0);
- ctx = intel_ctx_xe(xe, vm, engine,
+ ctx = intel_ctx_xe(xe, vm, exec_queue,
0, sync_bind, sync_out);
copyfns[copy_function].copyfn(xe, ctx,
region1, region2,
tiling, config);
- xe_engine_destroy(xe, engine);
+ xe_exec_queue_destroy(xe, exec_queue);
xe_vm_destroy(xe, vm);
syncobj_destroy(xe, sync_bind);
syncobj_destroy(xe, sync_out);
diff --git a/tests/xe/xe_create.c b/tests/xe/xe_create.c
index e39e89f7a..20e7a7da8 100644
--- a/tests/xe/xe_create.c
+++ b/tests/xe/xe_create.c
@@ -88,17 +88,17 @@ static void create_invalid_size(int fd)
xe_vm_destroy(fd, vm);
}
-enum engine_destroy {
+enum exec_queue_destroy {
NOLEAK,
LEAK
};
-static uint32_t __xe_engine_create(int fd, uint32_t vm,
+static uint32_t __xe_exec_queue_create(int fd, uint32_t vm,
struct drm_xe_engine_class_instance *instance,
uint64_t ext,
- uint32_t *enginep)
+ uint32_t *exec_queuep)
{
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.extensions = ext,
.vm_id = vm,
.width = 1,
@@ -107,10 +107,10 @@ static uint32_t __xe_engine_create(int fd, uint32_t vm,
};
int err = 0;
- if (igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE, &create) == 0) {
- *enginep = create.engine_id;
+ if (igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, &create) == 0) {
+ *exec_queuep = create.exec_queue_id;
} else {
- igt_warn("Can't create engine, errno: %d\n", errno);
+ igt_warn("Can't create exec_queue, errno: %d\n", errno);
err = -errno;
igt_assume(err);
}
@@ -119,58 +119,58 @@ static uint32_t __xe_engine_create(int fd, uint32_t vm,
return err;
}
-#define MAXENGINES 2048
+#define MAXEXECQUEUES 2048
#define MAXTIME 5
/**
- * SUBTEST: create-engines-%s
- * Description: Check process ability of multiple engines creation
+ * SUBTEST: create-execqueues-%s
+ * Description: Check process ability of multiple exec_queues creation
* Run type: FULL
*
* arg[1]:
*
- * @noleak: destroy engines in the code
- * @leak: destroy engines in close() path
+ * @noleak: destroy exec_queues in the code
+ * @leak: destroy exec_queues in close() path
*/
-static void create_engines(int fd, enum engine_destroy ed)
+static void create_execqueues(int fd, enum exec_queue_destroy ed)
{
struct timespec tv = { };
- uint32_t num_engines, engines_per_process, vm;
+ uint32_t num_engines, exec_queues_per_process, vm;
int nproc = sysconf(_SC_NPROCESSORS_ONLN), seconds;
fd = drm_reopen_driver(fd);
num_engines = xe_number_hw_engines(fd);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engines_per_process = max_t(uint32_t, 1, MAXENGINES / nproc);
- igt_debug("nproc: %u, engines per process: %u\n", nproc, engines_per_process);
+ exec_queues_per_process = max_t(uint32_t, 1, MAXEXECQUEUES / nproc);
+ igt_debug("nproc: %u, exec_queues per process: %u\n", nproc, exec_queues_per_process);
igt_nsec_elapsed(&tv);
igt_fork(n, nproc) {
struct drm_xe_engine_class_instance *hwe;
- uint32_t engine, engines[engines_per_process];
+ uint32_t exec_queue, exec_queues[exec_queues_per_process];
int idx, err, i;
srandom(n);
- for (i = 0; i < engines_per_process; i++) {
+ for (i = 0; i < exec_queues_per_process; i++) {
idx = rand() % num_engines;
hwe = xe_hw_engine(fd, idx);
- err = __xe_engine_create(fd, vm, hwe, 0, &engine);
- igt_debug("[%2d] Create engine: err=%d, engine=%u [idx = %d]\n",
- n, err, engine, i);
+ err = __xe_exec_queue_create(fd, vm, hwe, 0, &exec_queue);
+ igt_debug("[%2d] Create exec_queue: err=%d, exec_queue=%u [idx = %d]\n",
+ n, err, exec_queue, i);
if (err)
break;
if (ed == NOLEAK)
- engines[i] = engine;
+ exec_queues[i] = exec_queue;
}
if (ed == NOLEAK) {
while (--i >= 0) {
- igt_debug("[%2d] Destroy engine: %u\n", n, engines[i]);
- xe_engine_destroy(fd, engines[i]);
+ igt_debug("[%2d] Destroy exec_queue: %u\n", n, exec_queues[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
}
}
@@ -181,8 +181,8 @@ static void create_engines(int fd, enum engine_destroy ed)
seconds = igt_seconds_elapsed(&tv);
igt_assert_f(seconds < MAXTIME,
- "Creating %d engines tooks too long: %d [limit: %d]\n",
- MAXENGINES, seconds, MAXTIME);
+ "Creating %d exec_queues tooks too long: %d [limit: %d]\n",
+ MAXEXECQUEUES, seconds, MAXTIME);
}
/**
@@ -216,11 +216,11 @@ igt_main
create_invalid_size(xe);
}
- igt_subtest("create-engines-noleak")
- create_engines(xe, NOLEAK);
+ igt_subtest("create-execqueues-noleak")
+ create_execqueues(xe, NOLEAK);
- igt_subtest("create-engines-leak")
- create_engines(xe, LEAK);
+ igt_subtest("create-execqueues-leak")
+ create_execqueues(xe, LEAK);
igt_subtest("create-massive-size") {
create_massive_size(xe);
diff --git a/tests/xe/xe_dma_buf_sync.c b/tests/xe/xe_dma_buf_sync.c
index 4e76d85ab..29d675154 100644
--- a/tests/xe/xe_dma_buf_sync.c
+++ b/tests/xe/xe_dma_buf_sync.c
@@ -98,7 +98,7 @@ test_export_dma_buf(struct drm_xe_engine_class_instance *hwe0,
int dma_buf_fd[MAX_N_BO];
uint32_t import_bo[MAX_N_BO];
uint32_t vm[N_FD];
- uint32_t engine[N_FD];
+ uint32_t exec_queue[N_FD];
size_t bo_size;
struct {
struct xe_spin spin;
@@ -113,7 +113,7 @@ test_export_dma_buf(struct drm_xe_engine_class_instance *hwe0,
for (i = 0; i < N_FD; ++i) {
fd[i] = drm_open_driver(DRIVER_XE);
vm[i] = xe_vm_create(fd[i], 0, 0);
- engine[i] = xe_engine_create(fd[i], vm[i], !i ? hwe0 : hwe1, 0);
+ exec_queue[i] = xe_exec_queue_create(fd[i], vm[i], !i ? hwe0 : hwe1, 0);
}
bo_size = sizeof(*data[0]) * N_FD;
@@ -159,7 +159,7 @@ test_export_dma_buf(struct drm_xe_engine_class_instance *hwe0,
/* Write spinner on FD[0] */
xe_spin_init(&data[i]->spin, spin_addr, true);
- exec.engine_id = engine[0];
+ exec.exec_queue_id = exec_queue[0];
exec.address = spin_addr;
xe_exec(fd[0], &exec);
@@ -187,7 +187,7 @@ test_export_dma_buf(struct drm_xe_engine_class_instance *hwe0,
igt_assert(b <= ARRAY_SIZE(data[i]->batch));
sync[0].handle = syncobj;
sync[1].handle = syncobj_create(fd[1], 0);
- exec.engine_id = engine[1];
+ exec.exec_queue_id = exec_queue[1];
exec.address = batch_addr;
exec.num_syncs = 2;
xe_exec(fd[1], &exec);
diff --git a/tests/xe/xe_evict.c b/tests/xe/xe_evict.c
index c44cb80dc..b8f186809 100644
--- a/tests/xe/xe_evict.c
+++ b/tests/xe/xe_evict.c
@@ -20,22 +20,22 @@
#include "xe/xe_query.h"
#include <string.h>
-#define MAX_N_ENGINES 16
-#define MULTI_VM (0x1 << 0)
-#define THREADED (0x1 << 1)
-#define MIXED_THREADS (0x1 << 2)
-#define LEGACY_THREAD (0x1 << 3)
-#define COMPUTE_THREAD (0x1 << 4)
-#define EXTERNAL_OBJ (0x1 << 5)
-#define BIND_ENGINE (0x1 << 6)
+#define MAX_N_EXEC_QUEUES 16
+#define MULTI_VM (0x1 << 0)
+#define THREADED (0x1 << 1)
+#define MIXED_THREADS (0x1 << 2)
+#define LEGACY_THREAD (0x1 << 3)
+#define COMPUTE_THREAD (0x1 << 4)
+#define EXTERNAL_OBJ (0x1 << 5)
+#define BIND_EXEC_QUEUE (0x1 << 6)
static void
test_evict(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, size_t bo_size,
+ int n_exec_queues, int n_execs, size_t bo_size,
unsigned long flags, pthread_barrier_t *barrier)
{
uint32_t vm, vm2, vm3;
- uint32_t bind_engines[3] = { 0, 0, 0 };
+ uint32_t bind_exec_queues[3] = { 0, 0, 0 };
uint64_t addr = 0x100000000, base_addr = 0x100000000;
struct drm_xe_sync sync[2] = {
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
@@ -46,8 +46,8 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
uint32_t *bo;
struct {
uint32_t batch[16];
@@ -56,7 +56,7 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
} *data;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
bo = calloc(n_execs / 2, sizeof(*bo));
igt_assert(bo);
@@ -64,23 +64,23 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
fd = drm_open_driver(DRIVER_XE);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- if (flags & BIND_ENGINE)
- bind_engines[0] = xe_bind_engine_create(fd, vm, 0);
+ if (flags & BIND_EXEC_QUEUE)
+ bind_exec_queues[0] = xe_bind_exec_queue_create(fd, vm, 0);
if (flags & MULTI_VM) {
vm2 = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
vm3 = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- if (flags & BIND_ENGINE) {
- bind_engines[1] = xe_bind_engine_create(fd, vm2, 0);
- bind_engines[2] = xe_bind_engine_create(fd, vm3, 0);
+ if (flags & BIND_EXEC_QUEUE) {
+ bind_exec_queues[1] = xe_bind_exec_queue_create(fd, vm2, 0);
+ bind_exec_queues[2] = xe_bind_exec_queue_create(fd, vm3, 0);
}
}
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
if (flags & MULTI_VM)
- engines[i] = xe_engine_create(fd, i & 1 ? vm2 : vm ,
+ exec_queues[i] = xe_exec_queue_create(fd, i & 1 ? vm2 : vm ,
eci, 0);
else
- engines[i] = xe_engine_create(fd, vm, eci, 0);
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
syncobjs[i] = syncobj_create(fd, 0);
};
@@ -90,7 +90,7 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
uint32_t __bo;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
if (i < n_execs / 2) {
uint32_t _vm = (flags & EXTERNAL_OBJ) &&
@@ -122,17 +122,17 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
sync[0].handle = syncobj_create(fd, 0);
if (flags & MULTI_VM) {
- xe_vm_bind_async(fd, vm3, bind_engines[2], __bo,
+ xe_vm_bind_async(fd, vm3, bind_exec_queues[2], __bo,
0, addr,
bo_size, sync, 1);
igt_assert(syncobj_wait(fd, &sync[0].handle, 1,
INT64_MAX, 0, NULL));
xe_vm_bind_async(fd, i & 1 ? vm2 : vm,
- i & 1 ? bind_engines[1] :
- bind_engines[0], __bo,
+ i & 1 ? bind_exec_queues[1] :
+ bind_exec_queues[0], __bo,
0, addr, bo_size, sync, 1);
} else {
- xe_vm_bind_async(fd, vm, bind_engines[0],
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0],
__bo, 0, addr, bo_size,
sync, 1);
}
@@ -148,11 +148,11 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert(b <= ARRAY_SIZE(data[i].batch));
sync[0].flags &= ~DRM_XE_SYNC_SIGNAL;
- if (i >= n_engines)
+ if (i >= n_exec_queues)
syncobj_reset(fd, &syncobjs[e], 1);
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec), 0);
@@ -166,7 +166,7 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
}
munmap(data, ALIGN(sizeof(*data) * n_execs, 0x1000));
- for (i = 0; i < n_engines; i++)
+ for (i = 0; i < n_exec_queues; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -184,14 +184,14 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
munmap(data, ALIGN(sizeof(*data) * n_execs, 0x1000));
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
for (i = 0; i < 3; i++)
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
for (i = 0; i < n_execs / 2; i++)
gem_close(fd, bo[i]);
@@ -206,11 +206,11 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
static void
test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, size_t bo_size, unsigned long flags,
+ int n_exec_queues, int n_execs, size_t bo_size, unsigned long flags,
pthread_barrier_t *barrier)
{
uint32_t vm, vm2;
- uint32_t bind_engines[2] = { 0, 0 };
+ uint32_t bind_exec_queues[2] = { 0, 0 };
uint64_t addr = 0x100000000, base_addr = 0x100000000;
#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
struct drm_xe_sync sync[1] = {
@@ -222,7 +222,7 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
uint32_t *bo;
struct {
uint32_t batch[16];
@@ -233,7 +233,7 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
} *data;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
bo = calloc(n_execs / 2, sizeof(*bo));
igt_assert(bo);
@@ -242,28 +242,28 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS |
DRM_XE_VM_CREATE_COMPUTE_MODE, 0);
- if (flags & BIND_ENGINE)
- bind_engines[0] = xe_bind_engine_create(fd, vm, 0);
+ if (flags & BIND_EXEC_QUEUE)
+ bind_exec_queues[0] = xe_bind_exec_queue_create(fd, vm, 0);
if (flags & MULTI_VM) {
vm2 = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS |
DRM_XE_VM_CREATE_COMPUTE_MODE, 0);
- if (flags & BIND_ENGINE)
- bind_engines[1] = xe_bind_engine_create(fd, vm2, 0);
+ if (flags & BIND_EXEC_QUEUE)
+ bind_exec_queues[1] = xe_bind_exec_queue_create(fd, vm2, 0);
}
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property ext = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property ext = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
if (flags & MULTI_VM)
- engines[i] = xe_engine_create(fd, i & 1 ? vm2 : vm, eci,
+ exec_queues[i] = xe_exec_queue_create(fd, i & 1 ? vm2 : vm, eci,
to_user_pointer(&ext));
else
- engines[i] = xe_engine_create(fd, vm, eci,
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci,
to_user_pointer(&ext));
}
@@ -273,7 +273,7 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
uint32_t __bo;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
if (i < n_execs / 2) {
uint32_t _vm = (flags & EXTERNAL_OBJ) &&
@@ -307,11 +307,11 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].addr = to_user_pointer(&data[i].vm_sync);
if (flags & MULTI_VM) {
xe_vm_bind_async(fd, i & 1 ? vm2 : vm,
- i & 1 ? bind_engines[1] :
- bind_engines[0], __bo,
+ i & 1 ? bind_exec_queues[1] :
+ bind_exec_queues[0], __bo,
0, addr, bo_size, sync, 1);
} else {
- xe_vm_bind_async(fd, vm, bind_engines[0], __bo,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0], __bo,
0, addr, bo_size, sync, 1);
}
#define TWENTY_SEC MS_TO_NS(20000)
@@ -330,7 +330,7 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
data[i].batch[b++] = MI_BATCH_BUFFER_END;
igt_assert(b <= ARRAY_SIZE(data[i].batch));
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec), 0);
@@ -356,12 +356,12 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
}
munmap(data, ALIGN(sizeof(*data) * n_execs, 0x1000));
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
for (i = 0; i < 2; i++)
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
for (i = 0; i < n_execs / 2; i++)
gem_close(fd, bo[i]);
@@ -379,7 +379,7 @@ struct thread_data {
pthread_barrier_t *barrier;
int fd;
struct drm_xe_engine_class_instance *eci;
- int n_engines;
+ int n_exec_queues;
int n_execs;
uint64_t bo_size;
int flags;
@@ -396,10 +396,10 @@ static void *thread(void *data)
pthread_mutex_unlock(t->mutex);
if (t->flags & COMPUTE_THREAD)
- test_evict_cm(t->fd, t->eci, t->n_engines, t->n_execs,
+ test_evict_cm(t->fd, t->eci, t->n_exec_queues, t->n_execs,
t->bo_size, t->flags, t->barrier);
else
- test_evict(t->fd, t->eci, t->n_engines, t->n_execs,
+ test_evict(t->fd, t->eci, t->n_exec_queues, t->n_execs,
t->bo_size, t->flags, t->barrier);
return NULL;
@@ -407,7 +407,7 @@ static void *thread(void *data)
static void
threads(int fd, struct drm_xe_engine_class_instance *eci,
- int n_threads, int n_engines, int n_execs, size_t bo_size,
+ int n_threads, int n_exec_queues, int n_execs, size_t bo_size,
unsigned long flags)
{
pthread_barrier_t barrier;
@@ -430,7 +430,7 @@ threads(int fd, struct drm_xe_engine_class_instance *eci,
threads_data[i].barrier = &barrier;
threads_data[i].fd = fd;
threads_data[i].eci = eci;
- threads_data[i].n_engines = n_engines;
+ threads_data[i].n_exec_queues = n_exec_queues;
threads_data[i].n_execs = n_execs;
threads_data[i].bo_size = bo_size;
threads_data[i].flags = flags;
@@ -477,12 +477,12 @@ static uint64_t calc_bo_size(uint64_t vram_size, int mul, int div)
* @large: large
* @large-external: large external
* @large-multi-vm: large multi VM
- * @beng-small: small bind engine
- * @beng-small-external: small external bind engine
+ * @beng-small: small bind exec_queue
+ * @beng-small-external: small external bind exec_queue
* @beng-small-multi-vm: small multi VM bind ending
- * @beng-large: large bind engine
- * @beng-large-external: large external bind engine
- * @beng-large-multi-vm: large multi VM bind engine
+ * @beng-large: large bind exec_queue
+ * @beng-large-external: large external bind exec_queue
+ * @beng-large-multi-vm: large multi VM bind exec_queue
*
* @small-cm: small compute machine
* @small-external-cm: small external compute machine
@@ -490,12 +490,12 @@ static uint64_t calc_bo_size(uint64_t vram_size, int mul, int div)
* @large-cm: large compute machine
* @large-external-cm: large external compute machine
* @large-multi-vm-cm: large multi VM compute machine
- * @beng-small-cm: small bind engine compute machine
- * @beng-small-external-cm: small external bind engine compute machine
+ * @beng-small-cm: small bind exec_queue compute machine
+ * @beng-small-external-cm: small external bind exec_queue compute machine
* @beng-small-multi-vm-cm: small multi VM bind ending compute machine
- * @beng-large-cm: large bind engine compute machine
- * @beng-large-external-cm: large external bind engine compute machine
- * @beng-large-multi-vm-cm: large multi VM bind engine compute machine
+ * @beng-large-cm: large bind exec_queue compute machine
+ * @beng-large-external-cm: large external bind exec_queue compute machine
+ * @beng-large-multi-vm-cm: large multi VM bind exec_queue compute machine
*
* @threads-small: threads small
* @cm-threads-small: compute mode threads small
@@ -513,28 +513,28 @@ static uint64_t calc_bo_size(uint64_t vram_size, int mul, int div)
* @cm-threads-large-multi-vm: compute mode threads large multi vm
* @mixed-threads-large-multi-vm:
* mixed threads large multi vm
- * @beng-threads-small: bind engine threads small
- * @beng-cm-threads-small: bind engine compute mode threads small
- * @beng-mixed-threads-small: bind engine mixed threads small
+ * @beng-threads-small: bind exec_queue threads small
+ * @beng-cm-threads-small: bind exec_queue compute mode threads small
+ * @beng-mixed-threads-small: bind exec_queue mixed threads small
* @beng-mixed-many-threads-small:
- * bind engine mixed many threads small
- * @beng-threads-large: bind engine threads large
- * @beng-cm-threads-large: bind engine compute mode threads large
- * @beng-mixed-threads-large: bind engine mixed threads large
+ * bind exec_queue mixed many threads small
+ * @beng-threads-large: bind exec_queue threads large
+ * @beng-cm-threads-large: bind exec_queue compute mode threads large
+ * @beng-mixed-threads-large: bind exec_queue mixed threads large
* @beng-mixed-many-threads-large:
- * bind engine mixed many threads large
+ * bind exec_queue mixed many threads large
* @beng-threads-small-multi-vm:
- * bind engine threads small multi vm
+ * bind exec_queue threads small multi vm
* @beng-cm-threads-small-multi-vm:
- * bind engine compute mode threads small multi vm
+ * bind exec_queue compute mode threads small multi vm
* @beng-mixed-threads-small-multi-vm:
- * bind engine mixed threads small multi vm
+ * bind exec_queue mixed threads small multi vm
* @beng-threads-large-multi-vm:
- * bind engine threads large multi vm
+ * bind exec_queue threads large multi vm
* @beng-cm-threads-large-multi-vm:
- * bind engine compute mode threads large multi vm
+ * bind exec_queue compute mode threads large multi vm
* @beng-mixed-threads-large-multi-vm:
- * bind engine mixed threads large multi vm
+ * bind exec_queue mixed threads large multi vm
*/
/*
@@ -552,7 +552,7 @@ igt_main
struct drm_xe_engine_class_instance *hwe;
const struct section {
const char *name;
- int n_engines;
+ int n_exec_queues;
int n_execs;
int mul;
int div;
@@ -564,20 +564,20 @@ igt_main
{ "large", 4, 16, 1, 4, 0 },
{ "large-external", 4, 16, 1, 4, EXTERNAL_OBJ },
{ "large-multi-vm", 4, 8, 3, 8, MULTI_VM },
- { "beng-small", 16, 448, 1, 128, BIND_ENGINE },
- { "beng-small-external", 16, 448, 1, 128, BIND_ENGINE |
+ { "beng-small", 16, 448, 1, 128, BIND_EXEC_QUEUE },
+ { "beng-small-external", 16, 448, 1, 128, BIND_EXEC_QUEUE |
EXTERNAL_OBJ },
- { "beng-small-multi-vm", 16, 256, 1, 128, BIND_ENGINE |
+ { "beng-small-multi-vm", 16, 256, 1, 128, BIND_EXEC_QUEUE |
MULTI_VM },
- { "beng-large", 4, 16, 1, 4, BIND_ENGINE },
- { "beng-large-external", 4, 16, 1, 4, BIND_ENGINE |
+ { "beng-large", 4, 16, 1, 4, BIND_EXEC_QUEUE },
+ { "beng-large-external", 4, 16, 1, 4, BIND_EXEC_QUEUE |
EXTERNAL_OBJ },
- { "beng-large-multi-vm", 4, 8, 3, 8, BIND_ENGINE | MULTI_VM },
+ { "beng-large-multi-vm", 4, 8, 3, 8, BIND_EXEC_QUEUE | MULTI_VM },
{ NULL },
};
const struct section_cm {
const char *name;
- int n_engines;
+ int n_exec_queues;
int n_execs;
int mul;
int div;
@@ -589,22 +589,22 @@ igt_main
{ "large-cm", 4, 16, 1, 4, 0 },
{ "large-external-cm", 4, 16, 1, 4, EXTERNAL_OBJ },
{ "large-multi-vm-cm", 4, 8, 3, 8, MULTI_VM },
- { "beng-small-cm", 16, 448, 1, 128, BIND_ENGINE },
- { "beng-small-external-cm", 16, 448, 1, 128, BIND_ENGINE |
+ { "beng-small-cm", 16, 448, 1, 128, BIND_EXEC_QUEUE },
+ { "beng-small-external-cm", 16, 448, 1, 128, BIND_EXEC_QUEUE |
EXTERNAL_OBJ },
- { "beng-small-multi-vm-cm", 16, 256, 1, 128, BIND_ENGINE |
+ { "beng-small-multi-vm-cm", 16, 256, 1, 128, BIND_EXEC_QUEUE |
MULTI_VM },
- { "beng-large-cm", 4, 16, 1, 4, BIND_ENGINE },
- { "beng-large-external-cm", 4, 16, 1, 4, BIND_ENGINE |
+ { "beng-large-cm", 4, 16, 1, 4, BIND_EXEC_QUEUE },
+ { "beng-large-external-cm", 4, 16, 1, 4, BIND_EXEC_QUEUE |
EXTERNAL_OBJ },
- { "beng-large-multi-vm-cm", 4, 8, 3, 8, BIND_ENGINE |
+ { "beng-large-multi-vm-cm", 4, 8, 3, 8, BIND_EXEC_QUEUE |
MULTI_VM },
{ NULL },
};
const struct section_threads {
const char *name;
int n_threads;
- int n_engines;
+ int n_exec_queues;
int n_execs;
int mul;
int div;
@@ -639,33 +639,33 @@ igt_main
{ "mixed-threads-large-multi-vm", 2, 2, 4, 3, 8,
MIXED_THREADS | MULTI_VM | THREADED },
{ "beng-threads-small", 2, 16, 128, 1, 128,
- THREADED | BIND_ENGINE },
+ THREADED | BIND_EXEC_QUEUE },
{ "beng-cm-threads-small", 2, 16, 128, 1, 128,
- COMPUTE_THREAD | THREADED | BIND_ENGINE },
+ COMPUTE_THREAD | THREADED | BIND_EXEC_QUEUE },
{ "beng-mixed-threads-small", 2, 16, 128, 1, 128,
- MIXED_THREADS | THREADED | BIND_ENGINE },
+ MIXED_THREADS | THREADED | BIND_EXEC_QUEUE },
{ "beng-mixed-many-threads-small", 3, 16, 128, 1, 128,
- THREADED | BIND_ENGINE },
+ THREADED | BIND_EXEC_QUEUE },
{ "beng-threads-large", 2, 2, 4, 3, 8,
- THREADED | BIND_ENGINE },
+ THREADED | BIND_EXEC_QUEUE },
{ "beng-cm-threads-large", 2, 2, 4, 3, 8,
- COMPUTE_THREAD | THREADED | BIND_ENGINE },
+ COMPUTE_THREAD | THREADED | BIND_EXEC_QUEUE },
{ "beng-mixed-threads-large", 2, 2, 4, 3, 8,
- MIXED_THREADS | THREADED | BIND_ENGINE },
+ MIXED_THREADS | THREADED | BIND_EXEC_QUEUE },
{ "beng-mixed-many-threads-large", 3, 2, 4, 3, 8,
- THREADED | BIND_ENGINE },
+ THREADED | BIND_EXEC_QUEUE },
{ "beng-threads-small-multi-vm", 2, 16, 128, 1, 128,
- MULTI_VM | THREADED | BIND_ENGINE },
+ MULTI_VM | THREADED | BIND_EXEC_QUEUE },
{ "beng-cm-threads-small-multi-vm", 2, 16, 128, 1, 128,
- COMPUTE_THREAD | MULTI_VM | THREADED | BIND_ENGINE },
+ COMPUTE_THREAD | MULTI_VM | THREADED | BIND_EXEC_QUEUE },
{ "beng-mixed-threads-small-multi-vm", 2, 16, 128, 1, 128,
- MIXED_THREADS | MULTI_VM | THREADED | BIND_ENGINE },
+ MIXED_THREADS | MULTI_VM | THREADED | BIND_EXEC_QUEUE },
{ "beng-threads-large-multi-vm", 2, 2, 4, 3, 8,
- MULTI_VM | THREADED | BIND_ENGINE },
+ MULTI_VM | THREADED | BIND_EXEC_QUEUE },
{ "beng-cm-threads-large-multi-vm", 2, 2, 4, 3, 8,
- COMPUTE_THREAD | MULTI_VM | THREADED | BIND_ENGINE },
+ COMPUTE_THREAD | MULTI_VM | THREADED | BIND_EXEC_QUEUE },
{ "beng-mixed-threads-large-multi-vm", 2, 2, 4, 3, 8,
- MIXED_THREADS | MULTI_VM | THREADED | BIND_ENGINE },
+ MIXED_THREADS | MULTI_VM | THREADED | BIND_EXEC_QUEUE },
{ NULL },
};
uint64_t vram_size;
@@ -684,21 +684,21 @@ igt_main
for (const struct section *s = sections; s->name; s++) {
igt_subtest_f("evict-%s", s->name)
- test_evict(-1, hwe, s->n_engines, s->n_execs,
+ test_evict(-1, hwe, s->n_exec_queues, s->n_execs,
calc_bo_size(vram_size, s->mul, s->div),
s->flags, NULL);
}
for (const struct section_cm *s = sections_cm; s->name; s++) {
igt_subtest_f("evict-%s", s->name)
- test_evict_cm(-1, hwe, s->n_engines, s->n_execs,
+ test_evict_cm(-1, hwe, s->n_exec_queues, s->n_execs,
calc_bo_size(vram_size, s->mul, s->div),
s->flags, NULL);
}
for (const struct section_threads *s = sections_threads; s->name; s++) {
igt_subtest_f("evict-%s", s->name)
- threads(-1, hwe, s->n_threads, s->n_engines,
+ threads(-1, hwe, s->n_threads, s->n_exec_queues,
s->n_execs,
calc_bo_size(vram_size, s->mul, s->div),
s->flags);
diff --git a/tests/xe/xe_exec_balancer.c b/tests/xe/xe_exec_balancer.c
index 0b00d93de..f364a4b7a 100644
--- a/tests/xe/xe_exec_balancer.c
+++ b/tests/xe/xe_exec_balancer.c
@@ -4,10 +4,10 @@
*/
/**
- * TEST: Basic tests for execbuf functionality for virtual and parallel engines
+ * TEST: Basic tests for execbuf functionality for virtual and parallel exec_queues
* Category: Hardware building block
* Sub-category: execbuf
- * Functionality: virtual and parallel engines
+ * Functionality: virtual and parallel exec_queues
* Test category: functionality test
*/
@@ -28,7 +28,7 @@
/**
* SUBTEST: virtual-all-active
* Description:
- * Run a test to check if virtual engines can be running on all instances
+ * Run a test to check if virtual exec_queues can be running on all instances
* of a class simultaneously
* Run type: FULL
*/
@@ -45,7 +45,7 @@ static void test_all_active(int fd, int gt, int class)
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_INSTANCE];
+ uint32_t exec_queues[MAX_INSTANCE];
uint32_t syncobjs[MAX_INSTANCE];
size_t bo_size;
uint32_t bo = 0;
@@ -73,16 +73,16 @@ static void test_all_active(int fd, int gt, int class)
data = xe_bo_map(fd, bo, bo_size);
for (i = 0; i < num_placements; i++) {
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = 1,
.num_placements = num_placements,
.instances = to_user_pointer(eci),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
+ exec_queues[i] = create.exec_queue_id;
syncobjs[i] = syncobj_create(fd, 0);
};
@@ -98,7 +98,7 @@ static void test_all_active(int fd, int gt, int class)
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[i];
- exec.engine_id = engines[i];
+ exec.exec_queue_id = exec_queues[i];
exec.address = spin_addr;
xe_exec(fd, &exec);
xe_spin_wait_started(&data[i].spin);
@@ -118,7 +118,7 @@ static void test_all_active(int fd, int gt, int class)
syncobj_destroy(fd, sync[0].handle);
for (i = 0; i < num_placements; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
munmap(data, bo_size);
@@ -126,8 +126,8 @@ static void test_all_active(int fd, int gt, int class)
xe_vm_destroy(fd, vm);
}
-#define MAX_N_ENGINES 16
-#define USERPTR (0x1 << 0)
+#define MAX_N_EXEC_QUEUES 16
+#define USERPTR (0x1 << 0)
#define REBIND (0x1 << 1)
#define INVALIDATE (0x1 << 2)
#define RACE (0x1 << 3)
@@ -143,8 +143,8 @@ static void test_all_active(int fd, int gt, int class)
* Description: Run %arg[1] test many times
* Run type: FULL
*
- * SUBTEST: many-engines-%s
- * Description: Run %arg[1] test on many engines
+ * SUBTEST: many-execqueues-%s
+ * Description: Run %arg[1] test on many exec_queues
* Run type: FULL
*
* SUBTEST: twice-%s
@@ -171,7 +171,7 @@ static void test_all_active(int fd, int gt, int class)
* @parallel-userptr-invalidate-race: parallel userptr invalidate racy
*/
static void
-test_exec(int fd, int gt, int class, int n_engines, int n_execs,
+test_exec(int fd, int gt, int class, int n_exec_queues, int n_execs,
unsigned int flags)
{
uint32_t vm;
@@ -184,8 +184,8 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -197,7 +197,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
struct drm_xe_engine_class_instance eci[MAX_INSTANCE];
int i, j, b, num_placements = 0;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
xe_for_each_hw_engine(fd, hwe) {
if (hwe->engine_class != class || hwe->gt_id != gt)
@@ -229,17 +229,17 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
data = xe_bo_map(fd, bo, bo_size);
}
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_engine_create create = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = flags & PARALLEL ? num_placements : 1,
.num_placements = flags & PARALLEL ? 1 : num_placements,
.instances = to_user_pointer(eci),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
+ exec_queues[i] = create.exec_queue_id;
syncobjs[i] = syncobj_create(fd, 0);
};
exec.num_batch_buffer = flags & PARALLEL ? num_placements : 1;
@@ -257,7 +257,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
uint64_t batches[MAX_INSTANCE];
- int e = i % n_engines;
+ int e = i % n_exec_queues;
for (j = 0; j < num_placements && flags & PARALLEL; ++j)
batches[j] = batch_addr;
@@ -274,7 +274,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = flags & PARALLEL ?
to_user_pointer(batches) : batch_addr;
if (e != i)
@@ -325,7 +325,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
}
}
- for (i = 0; i < n_engines && n_execs; i++)
+ for (i = 0; i < n_exec_queues && n_execs; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -339,9 +339,9 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
igt_assert_eq(data[i].data, 0xc0ffee);
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
if (bo) {
@@ -355,25 +355,25 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
/**
* SUBTEST: once-cm-%s
- * Description: Run compute mode virtual engine arg[1] test only once
+ * Description: Run compute mode virtual exec_queue arg[1] test only once
*
* Run type: FULL
*
* SUBTEST: twice-cm-%s
- * Description: Run compute mode virtual engine arg[1] test twice
+ * Description: Run compute mode virtual exec_queue arg[1] test twice
* Run type: BAT
*
* SUBTEST: many-cm-%s
- * Description: Run compute mode virtual engine arg[1] test many times
+ * Description: Run compute mode virtual exec_queue arg[1] test many times
* Run type: FULL
*
- * SUBTEST: many-engines-cm-%s
- * Description: Run compute mode virtual engine arg[1] test on many engines
+ * SUBTEST: many-execqueues-cm-%s
+ * Description: Run compute mode virtual exec_queue arg[1] test on many exec_queues
* Run type: FULL
*
*
* SUBTEST: no-exec-cm-%s
- * Description: Run compute mode virtual engine arg[1] no-exec test
+ * Description: Run compute mode virtual exec_queue arg[1] no-exec test
* Run type: BAT
*
* arg[1]:
@@ -387,7 +387,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
*/
static void
-test_cm(int fd, int gt, int class, int n_engines, int n_execs,
+test_cm(int fd, int gt, int class, int n_exec_queues, int n_execs,
unsigned int flags)
{
uint32_t vm;
@@ -402,7 +402,7 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
.num_syncs = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -417,7 +417,7 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
int i, j, b, num_placements = 0;
int map_fd = -1;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
xe_for_each_hw_engine(fd, hwe) {
if (hwe->engine_class != class || hwe->gt_id != gt)
@@ -452,14 +452,14 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
}
memset(data, 0, bo_size);
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property ext = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property ext = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = 1,
.num_placements = num_placements,
@@ -467,9 +467,9 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
.extensions = to_user_pointer(&ext),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
+ exec_queues[i] = create.exec_queue_id;
}
sync[0].addr = to_user_pointer(&data[0].vm_sync);
@@ -488,7 +488,7 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -500,7 +500,7 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
sync[0].addr = addr + (char *)&data[i].exec_sync - (char *)data;
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -578,8 +578,8 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
i < n_execs; i++)
igt_assert_eq(data[i].data, 0xc0ffee);
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
if (bo) {
munmap(data, bo_size);
@@ -648,7 +648,7 @@ igt_main
64 : 1024,
s->flags);
- igt_subtest_f("many-engines-%s", s->name)
+ igt_subtest_f("many-execqueues-%s", s->name)
xe_for_each_gt(fd, gt)
xe_for_each_hw_engine_class(class)
test_exec(fd, gt, class, 16,
@@ -683,7 +683,7 @@ igt_main
64 : 1024,
s->flags);
- igt_subtest_f("many-engines-cm-%s", s->name)
+ igt_subtest_f("many-execqueues-cm-%s", s->name)
xe_for_each_gt(fd, gt)
xe_for_each_hw_engine_class(class)
test_cm(fd, gt, class, 16,
diff --git a/tests/xe/xe_exec_basic.c b/tests/xe/xe_exec_basic.c
index bf3863d48..46b8709a7 100644
--- a/tests/xe/xe_exec_basic.c
+++ b/tests/xe/xe_exec_basic.c
@@ -7,7 +7,7 @@
* TEST: Basic tests for execbuf functionality
* Category: Hardware building block
* Sub-category: execbuf
- * Functionality: engines
+ * Functionality: exec_queues
* Test category: functionality test
*/
@@ -20,15 +20,15 @@
#include "xe/xe_query.h"
#include <string.h>
-#define MAX_N_ENGINES 16
-#define USERPTR (0x1 << 0)
-#define REBIND (0x1 << 1)
-#define INVALIDATE (0x1 << 2)
-#define RACE (0x1 << 3)
-#define BIND_ENGINE (0x1 << 4)
-#define DEFER_ALLOC (0x1 << 5)
-#define DEFER_BIND (0x1 << 6)
-#define SPARSE (0x1 << 7)
+#define MAX_N_EXEC_QUEUES 16
+#define USERPTR (0x1 << 0)
+#define REBIND (0x1 << 1)
+#define INVALIDATE (0x1 << 2)
+#define RACE (0x1 << 3)
+#define BIND_EXEC_QUEUE (0x1 << 4)
+#define DEFER_ALLOC (0x1 << 5)
+#define DEFER_BIND (0x1 << 6)
+#define SPARSE (0x1 << 7)
/**
* SUBTEST: once-%s
@@ -39,12 +39,12 @@
* Description: Run %arg[1] test many times
* Run type: FULL
*
- * SUBTEST: many-engines-%s
- * Description: Run %arg[1] test on many engines
+ * SUBTEST: many-execqueues-%s
+ * Description: Run %arg[1] test on many exec_queues
* Run type: FULL
*
- * SUBTEST: many-engines-many-vm-%s
- * Description: Run %arg[1] test on many engines and many VMs
+ * SUBTEST: many-execqueues-many-vm-%s
+ * Description: Run %arg[1] test on many exec_queues and many VMs
* Run type: FULL
*
* SUBTEST: twice-%s
@@ -65,12 +65,12 @@
* @userptr-rebind: userptr rebind
* @userptr-invalidate: userptr invalidate
* @userptr-invalidate-race: userptr invalidate racy
- * @bindengine: bind engine
- * @bindengine-userptr: bind engine userptr description
- * @bindengine-rebind: bind engine rebind description
- * @bindengine-userptr-rebind: bind engine userptr rebind
- * @bindengine-userptr-invalidate: bind engine userptr invalidate
- * @bindengine-userptr-invalidate-race: bind engine userptr invalidate racy
+ * @bindexecqueue: bind exec_queue
+ * @bindexecqueue-userptr: bind exec_queue userptr description
+ * @bindexecqueue-rebind: bind exec_queue rebind description
+ * @bindexecqueue-userptr-rebind: bind exec_queue userptr rebind
+ * @bindexecqueue-userptr-invalidate: bind exec_queue userptr invalidate
+ * @bindexecqueue-userptr-invalidate-race: bind exec_queue userptr invalidate racy
* @null: null
* @null-defer-mmap: null defer mmap
* @null-defer-bind: null defer bind
@@ -79,7 +79,7 @@
static void
test_exec(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, int n_vm, unsigned int flags)
+ int n_exec_queues, int n_execs, int n_vm, unsigned int flags)
{
struct drm_xe_sync sync[2] = {
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
@@ -90,13 +90,13 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint64_t addr[MAX_N_ENGINES];
- uint64_t sparse_addr[MAX_N_ENGINES];
- uint32_t vm[MAX_N_ENGINES];
- uint32_t engines[MAX_N_ENGINES];
- uint32_t bind_engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
- uint32_t bind_syncobjs[MAX_N_ENGINES];
+ uint64_t addr[MAX_N_EXEC_QUEUES];
+ uint64_t sparse_addr[MAX_N_EXEC_QUEUES];
+ uint32_t vm[MAX_N_EXEC_QUEUES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t bind_exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
+ uint32_t bind_syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -106,8 +106,8 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
} *data;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
- igt_assert(n_vm <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
+ igt_assert(n_vm <= MAX_N_EXEC_QUEUES);
for (i = 0; i < n_vm; ++i)
vm[i] = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
@@ -117,7 +117,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
addr[0] = 0x1a0000;
sparse_addr[0] = 0x301a0000;
- for (i = 1; i < MAX_N_ENGINES; ++i) {
+ for (i = 1; i < MAX_N_EXEC_QUEUES; ++i) {
addr[i] = addr[i - 1] + (0x1ull << 32);
sparse_addr[i] = sparse_addr[i - 1] + (0x1ull << 32);
}
@@ -147,14 +147,14 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
data = xe_bo_map(fd, bo, bo_size);
}
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
uint32_t __vm = vm[i % n_vm];
- engines[i] = xe_engine_create(fd, __vm, eci, 0);
- if (flags & BIND_ENGINE)
- bind_engines[i] = xe_bind_engine_create(fd, __vm, 0);
+ exec_queues[i] = xe_exec_queue_create(fd, __vm, eci, 0);
+ if (flags & BIND_EXEC_QUEUE)
+ bind_exec_queues[i] = xe_bind_exec_queue_create(fd, __vm, 0);
else
- bind_engines[i] = 0;
+ bind_exec_queues[i] = 0;
syncobjs[i] = syncobj_create(fd, 0);
bind_syncobjs[i] = syncobj_create(fd, 0);
};
@@ -162,14 +162,14 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
for (i = 0; i < n_vm; ++i) {
sync[0].handle = bind_syncobjs[i];
if (bo)
- xe_vm_bind_async(fd, vm[i], bind_engines[i], bo, 0,
+ xe_vm_bind_async(fd, vm[i], bind_exec_queues[i], bo, 0,
addr[i], bo_size, sync, 1);
else
- xe_vm_bind_userptr_async(fd, vm[i], bind_engines[i],
+ xe_vm_bind_userptr_async(fd, vm[i], bind_exec_queues[i],
to_user_pointer(data), addr[i],
bo_size, sync, 1);
if (flags & SPARSE)
- __xe_vm_bind_assert(fd, vm[i], bind_engines[i],
+ __xe_vm_bind_assert(fd, vm[i], bind_exec_queues[i],
0, 0, sparse_addr[i], bo_size,
XE_VM_BIND_OP_MAP |
XE_VM_BIND_FLAG_ASYNC |
@@ -188,7 +188,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = (flags & SPARSE ? sparse_addr[i % n_vm] :
__addr)+ sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -203,7 +203,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
if (e != i)
syncobj_reset(fd, &syncobjs[e], 1);
@@ -213,18 +213,18 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
uint32_t __vm = vm[cur_vm];
sync[1].flags &= ~DRM_XE_SYNC_SIGNAL;
- xe_vm_unbind_async(fd, __vm, bind_engines[e], 0,
+ xe_vm_unbind_async(fd, __vm, bind_exec_queues[e], 0,
__addr, bo_size, sync + 1, 1);
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
addr[i % n_vm] += bo_size;
__addr = addr[i % n_vm];
if (bo)
- xe_vm_bind_async(fd, __vm, bind_engines[e], bo,
+ xe_vm_bind_async(fd, __vm, bind_exec_queues[e], bo,
0, __addr, bo_size, sync, 1);
else
xe_vm_bind_userptr_async(fd, __vm,
- bind_engines[e],
+ bind_exec_queues[e],
to_user_pointer(data),
__addr, bo_size, sync,
1);
@@ -257,7 +257,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
}
}
- for (i = 0; i < n_engines && n_execs; i++)
+ for (i = 0; i < n_exec_queues && n_execs; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
@@ -268,7 +268,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
for (i = 0; i < n_vm; ++i) {
syncobj_reset(fd, &sync[0].handle, 1);
- xe_vm_unbind_async(fd, vm[i], bind_engines[i], 0, addr[i],
+ xe_vm_unbind_async(fd, vm[i], bind_exec_queues[i], 0, addr[i],
bo_size, sync, 1);
igt_assert(syncobj_wait(fd, &sync[0].handle, 1,
INT64_MAX, 0, NULL));
@@ -280,11 +280,11 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert_eq(data[i].data, 0xc0ffee);
}
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
}
if (bo) {
@@ -318,13 +318,13 @@ igt_main
{ "userptr-rebind", USERPTR | REBIND },
{ "userptr-invalidate", USERPTR | INVALIDATE },
{ "userptr-invalidate-race", USERPTR | INVALIDATE | RACE },
- { "bindengine", BIND_ENGINE },
- { "bindengine-userptr", BIND_ENGINE | USERPTR },
- { "bindengine-rebind", BIND_ENGINE | REBIND },
- { "bindengine-userptr-rebind", BIND_ENGINE | USERPTR | REBIND },
- { "bindengine-userptr-invalidate", BIND_ENGINE | USERPTR |
+ { "bindexecqueue", BIND_EXEC_QUEUE },
+ { "bindexecqueue-userptr", BIND_EXEC_QUEUE | USERPTR },
+ { "bindexecqueue-rebind", BIND_EXEC_QUEUE | REBIND },
+ { "bindexecqueue-userptr-rebind", BIND_EXEC_QUEUE | USERPTR | REBIND },
+ { "bindexecqueue-userptr-invalidate", BIND_EXEC_QUEUE | USERPTR |
INVALIDATE },
- { "bindengine-userptr-invalidate-race", BIND_ENGINE | USERPTR |
+ { "bindexecqueue-userptr-invalidate-race", BIND_EXEC_QUEUE | USERPTR |
INVALIDATE | RACE },
{ NULL },
};
@@ -349,14 +349,14 @@ igt_main
64 : 1024, 1,
s->flags);
- igt_subtest_f("many-engines-%s", s->name)
+ igt_subtest_f("many-execqueues-%s", s->name)
xe_for_each_hw_engine(fd, hwe)
test_exec(fd, hwe, 16,
s->flags & (REBIND | INVALIDATE) ?
64 : 1024, 1,
s->flags);
- igt_subtest_f("many-engines-many-vm-%s", s->name)
+ igt_subtest_f("many-execqueues-many-vm-%s", s->name)
xe_for_each_hw_engine(fd, hwe)
test_exec(fd, hwe, 16,
s->flags & (REBIND | INVALIDATE) ?
diff --git a/tests/xe/xe_exec_compute_mode.c b/tests/xe/xe_exec_compute_mode.c
index ee9756c21..679b84fa1 100644
--- a/tests/xe/xe_exec_compute_mode.c
+++ b/tests/xe/xe_exec_compute_mode.c
@@ -22,14 +22,14 @@
#include "xe/xe_query.h"
#include <string.h>
-#define MAX_N_ENGINES 16
-#define USERPTR (0x1 << 0)
-#define REBIND (0x1 << 1)
-#define INVALIDATE (0x1 << 2)
-#define RACE (0x1 << 3)
-#define BIND_ENGINE (0x1 << 4)
-#define VM_FOR_BO (0x1 << 5)
-#define ENGINE_EARLY (0x1 << 6)
+#define MAX_N_EXECQUEUES 16
+#define USERPTR (0x1 << 0)
+#define REBIND (0x1 << 1)
+#define INVALIDATE (0x1 << 2)
+#define RACE (0x1 << 3)
+#define BIND_EXECQUEUE (0x1 << 4)
+#define VM_FOR_BO (0x1 << 5)
+#define EXEC_QUEUE_EARLY (0x1 << 6)
/**
* SUBTEST: twice-%s
@@ -53,18 +53,18 @@
* @userptr-rebind: userptr rebind
* @userptr-invalidate: userptr invalidate
* @userptr-invalidate-race: userptr invalidate race
- * @bindengine: bindengine
- * @bindengine-userptr: bindengine userptr
- * @bindengine-rebind: bindengine rebind
- * @bindengine-userptr-rebind: bindengine userptr rebind
- * @bindengine-userptr-invalidate: bindengine userptr invalidate
- * @bindengine-userptr-invalidate-race: bindengine-userptr invalidate race
+ * @bindexecqueue: bindexecqueue
+ * @bindexecqueue-userptr: bindexecqueue userptr
+ * @bindexecqueue-rebind: bindexecqueue rebind
+ * @bindexecqueue-userptr-rebind: bindexecqueue userptr rebind
+ * @bindexecqueue-userptr-invalidate: bindexecqueue userptr invalidate
+ * @bindexecqueue-userptr-invalidate-race: bindexecqueue-userptr invalidate race
*/
/**
*
- * SUBTEST: many-engines-%s
- * Description: Run %arg[1] compute machine test on many engines
+ * SUBTEST: many-execqueues-%s
+ * Description: Run %arg[1] compute machine test on many exec_queues
* Run type: FULL
*
* arg[1]:
@@ -75,15 +75,15 @@
* @rebind: rebind
* @userptr-rebind: userptr rebind
* @userptr-invalidate: userptr invalidate
- * @bindengine: bindengine
- * @bindengine-userptr: bindengine userptr
- * @bindengine-rebind: bindengine rebind
- * @bindengine-userptr-rebind: bindengine userptr rebind
- * @bindengine-userptr-invalidate: bindengine userptr invalidate
+ * @bindexecqueue: bindexec_queue
+ * @bindexecqueue-userptr: bindexecqueue userptr
+ * @bindexecqueue-rebind: bindexecqueue rebind
+ * @bindexecqueue-userptr-rebind: bindexecqueue userptr rebind
+ * @bindexecqueue-userptr-invalidate: bindexecqueue userptr invalidate
*/
static void
test_exec(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, unsigned int flags)
+ int n_exec_queues, int n_execs, unsigned int flags)
{
uint32_t vm;
uint64_t addr = 0x1a0000;
@@ -97,8 +97,8 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t bind_engines[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXECQUEUES];
+ uint32_t bind_exec_queues[MAX_N_EXECQUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -112,7 +112,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
int map_fd = -1;
int64_t fence_timeout;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXECQUEUES);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS |
DRM_XE_VM_CREATE_COMPUTE_MODE, 0);
@@ -120,21 +120,21 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
xe_get_default_alignment(fd));
- for (i = 0; (flags & ENGINE_EARLY) && i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property ext = {
+ for (i = 0; (flags & EXEC_QUEUE_EARLY) && i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property ext = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
- engines[i] = xe_engine_create(fd, vm, eci,
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci,
to_user_pointer(&ext));
- if (flags & BIND_ENGINE)
- bind_engines[i] =
- xe_bind_engine_create(fd, vm, 0);
+ if (flags & BIND_EXECQUEUE)
+ bind_exec_queues[i] =
+ xe_bind_exec_queue_create(fd, vm, 0);
else
- bind_engines[i] = 0;
+ bind_exec_queues[i] = 0;
};
if (flags & USERPTR) {
@@ -156,29 +156,29 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
}
memset(data, 0, bo_size);
- for (i = 0; !(flags & ENGINE_EARLY) && i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property ext = {
+ for (i = 0; !(flags & EXEC_QUEUE_EARLY) && i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property ext = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
- engines[i] = xe_engine_create(fd, vm, eci,
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci,
to_user_pointer(&ext));
- if (flags & BIND_ENGINE)
- bind_engines[i] =
- xe_bind_engine_create(fd, vm, 0);
+ if (flags & BIND_EXECQUEUE)
+ bind_exec_queues[i] =
+ xe_bind_exec_queue_create(fd, vm, 0);
else
- bind_engines[i] = 0;
+ bind_exec_queues[i] = 0;
};
sync[0].addr = to_user_pointer(&data[0].vm_sync);
if (bo)
- xe_vm_bind_async(fd, vm, bind_engines[0], bo, 0, addr,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0], bo, 0, addr,
bo_size, sync, 1);
else
- xe_vm_bind_userptr_async(fd, vm, bind_engines[0],
+ xe_vm_bind_userptr_async(fd, vm, bind_exec_queues[0],
to_user_pointer(data), addr,
bo_size, sync, 1);
#define ONE_SEC MS_TO_NS(1000)
@@ -195,7 +195,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -207,24 +207,24 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].addr = addr + (char *)&data[i].exec_sync - (char *)data;
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
if (flags & REBIND && i + 1 != n_execs) {
xe_wait_ufence(fd, &data[i].exec_sync, USER_FENCE_VALUE,
NULL, fence_timeout);
- xe_vm_unbind_async(fd, vm, bind_engines[e], 0,
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[e], 0,
addr, bo_size, NULL, 0);
sync[0].addr = to_user_pointer(&data[0].vm_sync);
addr += bo_size;
if (bo)
- xe_vm_bind_async(fd, vm, bind_engines[e], bo,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[e], bo,
0, addr, bo_size, sync, 1);
else
xe_vm_bind_userptr_async(fd, vm,
- bind_engines[e],
+ bind_exec_queues[e],
to_user_pointer(data),
addr, bo_size, sync,
1);
@@ -280,7 +280,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
usleep(250000);
sync[0].addr = to_user_pointer(&data[0].vm_sync);
- xe_vm_unbind_async(fd, vm, bind_engines[0], 0, addr, bo_size,
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[0], 0, addr, bo_size,
sync, 1);
xe_wait_ufence(fd, &data[0].vm_sync, USER_FENCE_VALUE, NULL,
fence_timeout);
@@ -288,10 +288,10 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
for (i = j; i < n_execs; i++)
igt_assert_eq(data[i].data, 0xc0ffee);
- for (i = 0; i < n_engines; i++) {
- xe_engine_destroy(fd, engines[i]);
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ for (i = 0; i < n_exec_queues; i++) {
+ xe_exec_queue_destroy(fd, exec_queues[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
}
if (bo) {
@@ -313,20 +313,20 @@ igt_main
unsigned int flags;
} sections[] = {
{ "basic", 0 },
- { "preempt-fence-early", VM_FOR_BO | ENGINE_EARLY },
+ { "preempt-fence-early", VM_FOR_BO | EXEC_QUEUE_EARLY },
{ "userptr", USERPTR },
{ "rebind", REBIND },
{ "userptr-rebind", USERPTR | REBIND },
{ "userptr-invalidate", USERPTR | INVALIDATE },
{ "userptr-invalidate-race", USERPTR | INVALIDATE | RACE },
- { "bindengine", BIND_ENGINE },
- { "bindengine-userptr", BIND_ENGINE | USERPTR },
- { "bindengine-rebind", BIND_ENGINE | REBIND },
- { "bindengine-userptr-rebind", BIND_ENGINE | USERPTR |
+ { "bindexecqueue", BIND_EXECQUEUE },
+ { "bindexecqueue-userptr", BIND_EXECQUEUE | USERPTR },
+ { "bindexecqueue-rebind", BIND_EXECQUEUE | REBIND },
+ { "bindexecqueue-userptr-rebind", BIND_EXECQUEUE | USERPTR |
REBIND },
- { "bindengine-userptr-invalidate", BIND_ENGINE | USERPTR |
+ { "bindexecqueue-userptr-invalidate", BIND_EXECQUEUE | USERPTR |
INVALIDATE },
- { "bindengine-userptr-invalidate-race", BIND_ENGINE | USERPTR |
+ { "bindexecqueue-userptr-invalidate-race", BIND_EXECQUEUE | USERPTR |
INVALIDATE | RACE },
{ NULL },
};
@@ -354,7 +354,7 @@ igt_main
if (s->flags & RACE)
continue;
- igt_subtest_f("many-engines-%s", s->name)
+ igt_subtest_f("many-execqueues-%s", s->name)
xe_for_each_hw_engine(fd, hwe)
test_exec(fd, hwe, 16,
s->flags & (REBIND | INVALIDATE) ?
diff --git a/tests/xe/xe_exec_fault_mode.c b/tests/xe/xe_exec_fault_mode.c
index 7dcbb3c45..85c010039 100644
--- a/tests/xe/xe_exec_fault_mode.c
+++ b/tests/xe/xe_exec_fault_mode.c
@@ -4,7 +4,7 @@
*/
/**
- * TEST: Basic tests for execbuf functionality for virtual and parallel engines
+ * TEST: Basic tests for execbuf functionality for virtual and parallel exec_queues
* Category: Hardware building block
* Sub-category: execbuf
* Functionality: fault mode
@@ -23,16 +23,16 @@
#include "xe/xe_query.h"
#include <string.h>
-#define MAX_N_ENGINES 16
-#define USERPTR (0x1 << 0)
-#define REBIND (0x1 << 1)
-#define INVALIDATE (0x1 << 2)
-#define RACE (0x1 << 3)
-#define BIND_ENGINE (0x1 << 4)
-#define WAIT_ATOMIC (0x1 << 5)
-#define IMMEDIATE (0x1 << 6)
-#define PREFETCH (0x1 << 7)
-#define INVALID_FAULT (0x1 << 8)
+#define MAX_N_EXEC_QUEUES 16
+#define USERPTR (0x1 << 0)
+#define REBIND (0x1 << 1)
+#define INVALIDATE (0x1 << 2)
+#define RACE (0x1 << 3)
+#define BIND_EXEC_QUEUE (0x1 << 4)
+#define WAIT_ATOMIC (0x1 << 5)
+#define IMMEDIATE (0x1 << 6)
+#define PREFETCH (0x1 << 7)
+#define INVALID_FAULT (0x1 << 8)
/**
* SUBTEST: once-%s
@@ -47,8 +47,8 @@
* Description: Run %arg[1] fault mode test many times
* Run type: FULL
*
- * SUBTEST: many-engines-%s
- * Description: Run %arg[1] fault mode test on many engines
+ * SUBTEST: many-execqueues-%s
+ * Description: Run %arg[1] fault mode test on many exec_queues
* Run type: FULL
*
* arg[1]:
@@ -59,50 +59,50 @@
* @userptr-rebind: userptr rebind
* @userptr-invalidate: userptr invalidate
* @userptr-invalidate-race: userptr invalidate race
- * @bindengine: bindengine
- * @bindengine-userptr: bindengine userptr
- * @bindengine-rebind: bindengine rebind
- * @bindengine-userptr-rebind: bindengine userptr rebind
- * @bindengine-userptr-invalidate:
- * bindengine userptr invalidate
- * @bindengine-userptr-invalidate-race:
- * bindengine userptr invalidate race
+ * @bindexecqueue: bindexecqueue
+ * @bindexecqueue-userptr: bindexecqueue userptr
+ * @bindexecqueue-rebind: bindexecqueue rebind
+ * @bindexecqueue-userptr-rebind: bindexecqueue userptr rebind
+ * @bindexecqueue-userptr-invalidate:
+ * bindexecqueue userptr invalidate
+ * @bindexecqueue-userptr-invalidate-race:
+ * bindexecqueue userptr invalidate race
* @basic-imm: basic imm
* @userptr-imm: userptr imm
* @rebind-imm: rebind imm
* @userptr-rebind-imm: userptr rebind imm
* @userptr-invalidate-imm: userptr invalidate imm
* @userptr-invalidate-race-imm: userptr invalidate race imm
- * @bindengine-imm: bindengine imm
- * @bindengine-userptr-imm: bindengine userptr imm
- * @bindengine-rebind-imm: bindengine rebind imm
- * @bindengine-userptr-rebind-imm:
- * bindengine userptr rebind imm
- * @bindengine-userptr-invalidate-imm:
- * bindengine userptr invalidate imm
- * @bindengine-userptr-invalidate-race-imm:
- * bindengine userptr invalidate race imm
+ * @bindexecqueue-imm: bindexecqueue imm
+ * @bindexecqueue-userptr-imm: bindexecqueue userptr imm
+ * @bindexecqueue-rebind-imm: bindexecqueue rebind imm
+ * @bindexecqueue-userptr-rebind-imm:
+ * bindexecqueue userptr rebind imm
+ * @bindexecqueue-userptr-invalidate-imm:
+ * bindexecqueue userptr invalidate imm
+ * @bindexecqueue-userptr-invalidate-race-imm:
+ * bindexecqueue userptr invalidate race imm
* @basic-prefetch: basic prefetch
* @userptr-prefetch: userptr prefetch
* @rebind-prefetch: rebind prefetch
* @userptr-rebind-prefetch: userptr rebind prefetch
* @userptr-invalidate-prefetch: userptr invalidate prefetch
* @userptr-invalidate-race-prefetch: userptr invalidate race prefetch
- * @bindengine-prefetch: bindengine prefetch
- * @bindengine-userptr-prefetch: bindengine userptr prefetch
- * @bindengine-rebind-prefetch: bindengine rebind prefetch
- * @bindengine-userptr-rebind-prefetch: bindengine userptr rebind prefetch
- * @bindengine-userptr-invalidate-prefetch:
- * bindengine userptr invalidate prefetch
- * @bindengine-userptr-invalidate-race-prefetch:
- * bindengine userptr invalidate race prefetch
+ * @bindexecqueue-prefetch: bindexecqueue prefetch
+ * @bindexecqueue-userptr-prefetch: bindexecqueue userptr prefetch
+ * @bindexecqueue-rebind-prefetch: bindexecqueue rebind prefetch
+ * @bindexecqueue-userptr-rebind-prefetch: bindexecqueue userptr rebind prefetch
+ * @bindexecqueue-userptr-invalidate-prefetch:
+ * bindexecqueue userptr invalidate prefetch
+ * @bindexecqueue-userptr-invalidate-race-prefetch:
+ * bindexecqueue userptr invalidate race prefetch
* @invalid-fault: invalid fault
* @invalid-userptr-fault: invalid userptr fault
*/
static void
test_exec(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, unsigned int flags)
+ int n_exec_queues, int n_execs, unsigned int flags)
{
uint32_t vm;
uint64_t addr = 0x1a0000;
@@ -116,8 +116,8 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t bind_engines[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t bind_exec_queues[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -130,7 +130,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
int i, j, b;
int map_fd = -1;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS |
DRM_XE_VM_CREATE_FAULT_MODE, 0);
@@ -162,32 +162,32 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
}
memset(data, 0, bo_size);
- for (i = 0; i < n_engines; i++) {
- engines[i] = xe_engine_create(fd, vm, eci, 0);
- if (flags & BIND_ENGINE)
- bind_engines[i] =
- xe_bind_engine_create(fd, vm, 0);
+ for (i = 0; i < n_exec_queues; i++) {
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
+ if (flags & BIND_EXEC_QUEUE)
+ bind_exec_queues[i] =
+ xe_bind_exec_queue_create(fd, vm, 0);
else
- bind_engines[i] = 0;
+ bind_exec_queues[i] = 0;
};
sync[0].addr = to_user_pointer(&data[0].vm_sync);
if (flags & IMMEDIATE) {
if (bo)
- xe_vm_bind_async_flags(fd, vm, bind_engines[0], bo, 0,
+ xe_vm_bind_async_flags(fd, vm, bind_exec_queues[0], bo, 0,
addr, bo_size, sync, 1,
XE_VM_BIND_FLAG_IMMEDIATE);
else
- xe_vm_bind_userptr_async_flags(fd, vm, bind_engines[0],
+ xe_vm_bind_userptr_async_flags(fd, vm, bind_exec_queues[0],
to_user_pointer(data),
addr, bo_size, sync, 1,
XE_VM_BIND_FLAG_IMMEDIATE);
} else {
if (bo)
- xe_vm_bind_async(fd, vm, bind_engines[0], bo, 0, addr,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0], bo, 0, addr,
bo_size, sync, 1);
else
- xe_vm_bind_userptr_async(fd, vm, bind_engines[0],
+ xe_vm_bind_userptr_async(fd, vm, bind_exec_queues[0],
to_user_pointer(data), addr,
bo_size, sync, 1);
}
@@ -198,7 +198,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
if (flags & PREFETCH) {
/* Should move to system memory */
- xe_vm_prefetch_async(fd, vm, bind_engines[0], 0, addr,
+ xe_vm_prefetch_async(fd, vm, bind_exec_queues[0], 0, addr,
bo_size, sync, 1, 0);
xe_wait_ufence(fd, &data[0].vm_sync, USER_FENCE_VALUE, NULL,
ONE_SEC);
@@ -210,7 +210,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -222,24 +222,24 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].addr = addr + (char *)&data[i].exec_sync - (char *)data;
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
if (flags & REBIND && i + 1 != n_execs) {
xe_wait_ufence(fd, &data[i].exec_sync, USER_FENCE_VALUE,
NULL, ONE_SEC);
- xe_vm_unbind_async(fd, vm, bind_engines[e], 0,
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[e], 0,
addr, bo_size, NULL, 0);
sync[0].addr = to_user_pointer(&data[0].vm_sync);
addr += bo_size;
if (bo)
- xe_vm_bind_async(fd, vm, bind_engines[e], bo,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[e], bo,
0, addr, bo_size, sync, 1);
else
xe_vm_bind_userptr_async(fd, vm,
- bind_engines[e],
+ bind_exec_queues[e],
to_user_pointer(data),
addr, bo_size, sync,
1);
@@ -292,7 +292,7 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
}
sync[0].addr = to_user_pointer(&data[0].vm_sync);
- xe_vm_unbind_async(fd, vm, bind_engines[0], 0, addr, bo_size,
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[0], 0, addr, bo_size,
sync, 1);
xe_wait_ufence(fd, &data[0].vm_sync, USER_FENCE_VALUE, NULL, ONE_SEC);
@@ -301,10 +301,10 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert_eq(data[i].data, 0xc0ffee);
}
- for (i = 0; i < n_engines; i++) {
- xe_engine_destroy(fd, engines[i]);
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ for (i = 0; i < n_exec_queues; i++) {
+ xe_exec_queue_destroy(fd, exec_queues[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
}
if (bo) {
@@ -356,7 +356,7 @@ test_atomic(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engine;
+ uint32_t exec_queue;
size_t bo_size;
uint32_t bo, bo_wait;
struct {
@@ -394,7 +394,7 @@ test_atomic(int fd, struct drm_xe_engine_class_instance *eci,
memset(data, 0, bo_size);
memset(wait, 0, bo_size);
- engine = xe_engine_create(fd, vm, eci, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
sync[0].addr = to_user_pointer(&wait[wait_idx].vm_sync);
xe_vm_bind_async(fd, vm, 0, bo, 0, addr, bo_size, sync, 1);
@@ -426,7 +426,7 @@ test_atomic(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].addr = addr_wait +
(char *)&wait[i].exec_sync - (char *)wait;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -450,7 +450,7 @@ test_atomic(int fd, struct drm_xe_engine_class_instance *eci,
xe_wait_ufence(fd, &wait[wait_idx++].vm_sync, USER_FENCE_VALUE, NULL,
ONE_SEC);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
munmap(data, bo_size);
munmap(wait, bo_size);
gem_close(fd, bo);
@@ -471,14 +471,14 @@ igt_main
{ "userptr-rebind", USERPTR | REBIND },
{ "userptr-invalidate", USERPTR | INVALIDATE },
{ "userptr-invalidate-race", USERPTR | INVALIDATE | RACE },
- { "bindengine", BIND_ENGINE },
- { "bindengine-userptr", BIND_ENGINE | USERPTR },
- { "bindengine-rebind", BIND_ENGINE | REBIND },
- { "bindengine-userptr-rebind", BIND_ENGINE | USERPTR |
+ { "bindexecqueue", BIND_EXEC_QUEUE },
+ { "bindexecqueue-userptr", BIND_EXEC_QUEUE | USERPTR },
+ { "bindexecqueue-rebind", BIND_EXEC_QUEUE | REBIND },
+ { "bindexecqueue-userptr-rebind", BIND_EXEC_QUEUE | USERPTR |
REBIND },
- { "bindengine-userptr-invalidate", BIND_ENGINE | USERPTR |
+ { "bindexecqueue-userptr-invalidate", BIND_EXEC_QUEUE | USERPTR |
INVALIDATE },
- { "bindengine-userptr-invalidate-race", BIND_ENGINE | USERPTR |
+ { "bindexecqueue-userptr-invalidate-race", BIND_EXEC_QUEUE | USERPTR |
INVALIDATE | RACE },
{ "basic-imm", IMMEDIATE },
{ "userptr-imm", IMMEDIATE | USERPTR },
@@ -487,15 +487,15 @@ igt_main
{ "userptr-invalidate-imm", IMMEDIATE | USERPTR | INVALIDATE },
{ "userptr-invalidate-race-imm", IMMEDIATE | USERPTR |
INVALIDATE | RACE },
- { "bindengine-imm", IMMEDIATE | BIND_ENGINE },
- { "bindengine-userptr-imm", IMMEDIATE | BIND_ENGINE | USERPTR },
- { "bindengine-rebind-imm", IMMEDIATE | BIND_ENGINE | REBIND },
- { "bindengine-userptr-rebind-imm", IMMEDIATE | BIND_ENGINE |
+ { "bindexecqueue-imm", IMMEDIATE | BIND_EXEC_QUEUE },
+ { "bindexecqueue-userptr-imm", IMMEDIATE | BIND_EXEC_QUEUE | USERPTR },
+ { "bindexecqueue-rebind-imm", IMMEDIATE | BIND_EXEC_QUEUE | REBIND },
+ { "bindexecqueue-userptr-rebind-imm", IMMEDIATE | BIND_EXEC_QUEUE |
USERPTR | REBIND },
- { "bindengine-userptr-invalidate-imm", IMMEDIATE | BIND_ENGINE |
+ { "bindexecqueue-userptr-invalidate-imm", IMMEDIATE | BIND_EXEC_QUEUE |
USERPTR | INVALIDATE },
- { "bindengine-userptr-invalidate-race-imm", IMMEDIATE |
- BIND_ENGINE | USERPTR | INVALIDATE | RACE },
+ { "bindexecqueue-userptr-invalidate-race-imm", IMMEDIATE |
+ BIND_EXEC_QUEUE | USERPTR | INVALIDATE | RACE },
{ "basic-prefetch", PREFETCH },
{ "userptr-prefetch", PREFETCH | USERPTR },
{ "rebind-prefetch", PREFETCH | REBIND },
@@ -503,15 +503,15 @@ igt_main
{ "userptr-invalidate-prefetch", PREFETCH | USERPTR | INVALIDATE },
{ "userptr-invalidate-race-prefetch", PREFETCH | USERPTR |
INVALIDATE | RACE },
- { "bindengine-prefetch", PREFETCH | BIND_ENGINE },
- { "bindengine-userptr-prefetch", PREFETCH | BIND_ENGINE | USERPTR },
- { "bindengine-rebind-prefetch", PREFETCH | BIND_ENGINE | REBIND },
- { "bindengine-userptr-rebind-prefetch", PREFETCH | BIND_ENGINE |
+ { "bindexecqueue-prefetch", PREFETCH | BIND_EXEC_QUEUE },
+ { "bindexecqueue-userptr-prefetch", PREFETCH | BIND_EXEC_QUEUE | USERPTR },
+ { "bindexecqueue-rebind-prefetch", PREFETCH | BIND_EXEC_QUEUE | REBIND },
+ { "bindexecqueue-userptr-rebind-prefetch", PREFETCH | BIND_EXEC_QUEUE |
USERPTR | REBIND },
- { "bindengine-userptr-invalidate-prefetch", PREFETCH | BIND_ENGINE |
+ { "bindexecqueue-userptr-invalidate-prefetch", PREFETCH | BIND_EXEC_QUEUE |
USERPTR | INVALIDATE },
- { "bindengine-userptr-invalidate-race-prefetch", PREFETCH |
- BIND_ENGINE | USERPTR | INVALIDATE | RACE },
+ { "bindexecqueue-userptr-invalidate-race-prefetch", PREFETCH |
+ BIND_EXEC_QUEUE | USERPTR | INVALIDATE | RACE },
{ "invalid-fault", INVALID_FAULT },
{ "invalid-userptr-fault", INVALID_FAULT | USERPTR },
{ NULL },
@@ -539,7 +539,7 @@ igt_main
64 : 128,
s->flags);
- igt_subtest_f("many-engines-%s", s->name)
+ igt_subtest_f("many-execqueues-%s", s->name)
xe_for_each_hw_engine(fd, hwe)
test_exec(fd, hwe, 16,
s->flags & (REBIND | INVALIDATE) ?
diff --git a/tests/xe/xe_exec_reset.c b/tests/xe/xe_exec_reset.c
index dfbaa6035..a2d33baf1 100644
--- a/tests/xe/xe_exec_reset.c
+++ b/tests/xe/xe_exec_reset.c
@@ -4,7 +4,7 @@
*/
/**
- * TEST: Basic tests for execbuf functionality for virtual and parallel engines
+ * TEST: Basic tests for execbuf functionality for virtual and parallel exec_queues
* Category: Hardware building block
* Sub-category: execbuf
* Functionality: reset
@@ -39,7 +39,7 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engine;
+ uint32_t exec_queue;
uint32_t syncobj;
size_t bo_size;
uint32_t bo = 0;
@@ -54,7 +54,7 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
visible_vram_if_possible(fd, eci->gt_id));
spin = xe_bo_map(fd, bo, bo_size);
- engine = xe_engine_create(fd, vm, eci, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
syncobj = syncobj_create(fd, 0);
sync[0].handle = syncobj_create(fd, 0);
@@ -66,7 +66,7 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobj;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = addr;
xe_exec(fd, &exec);
@@ -84,31 +84,31 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
syncobj_destroy(fd, sync[0].handle);
syncobj_destroy(fd, syncobj);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
munmap(spin, bo_size);
gem_close(fd, bo);
xe_vm_destroy(fd, vm);
}
-#define MAX_N_ENGINES 16
-#define MAX_INSTANCE 9
-#define CANCEL (0x1 << 0)
-#define ENGINE_RESET (0x1 << 1)
-#define GT_RESET (0x1 << 2)
-#define CLOSE_FD (0x1 << 3)
-#define CLOSE_ENGINES (0x1 << 4)
-#define VIRTUAL (0x1 << 5)
-#define PARALLEL (0x1 << 6)
-#define CAT_ERROR (0x1 << 7)
+#define MAX_N_EXECQUEUES 16
+#define MAX_INSTANCE 9
+#define CANCEL (0x1 << 0)
+#define EXEC_QUEUE_RESET (0x1 << 1)
+#define GT_RESET (0x1 << 2)
+#define CLOSE_FD (0x1 << 3)
+#define CLOSE_EXEC_QUEUES (0x1 << 4)
+#define VIRTUAL (0x1 << 5)
+#define PARALLEL (0x1 << 6)
+#define CAT_ERROR (0x1 << 7)
/**
* SUBTEST: %s-cancel
* Description: Test %arg[1] cancel
* Run type: FULL
*
- * SUBTEST: %s-engine-reset
- * Description: Test %arg[1] engine reset
+ * SUBTEST: %s-execqueue-reset
+ * Description: Test %arg[1] exec_queue reset
* Run type: FULL
*
* SUBTEST: %s-cat-error
@@ -131,8 +131,8 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
* Description: Test %arg[1] close fd
* Run type: FULL
*
- * SUBTEST: %s-close-engines-close-fd
- * Description: Test %arg[1] close engines close fd
+ * SUBTEST: %s-close-execqueues-close-fd
+ * Description: Test %arg[1] close exec_queues close fd
* Run type: FULL
*
* arg[1]:
@@ -142,7 +142,7 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
*/
static void
-test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
+test_balancer(int fd, int gt, int class, int n_exec_queues, int n_execs,
unsigned int flags)
{
uint32_t vm;
@@ -155,8 +155,8 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXECQUEUES];
+ uint32_t syncobjs[MAX_N_EXECQUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -169,7 +169,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
struct drm_xe_engine_class_instance eci[MAX_INSTANCE];
int i, j, b, num_placements = 0, bad_batches = 1;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXECQUEUES);
if (flags & CLOSE_FD)
fd = drm_open_driver(DRIVER_XE);
@@ -191,20 +191,20 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
data = xe_bo_map(fd, bo, bo_size);
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property job_timeout = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property job_timeout = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_JOB_TIMEOUT,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_JOB_TIMEOUT,
.value = 50,
};
- struct drm_xe_ext_engine_set_property preempt_timeout = {
+ struct drm_xe_ext_exec_queue_set_property preempt_timeout = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_PREEMPTION_TIMEOUT,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_PREEMPTION_TIMEOUT,
.value = 1000,
};
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = flags & PARALLEL ? num_placements : 1,
.num_placements = flags & PARALLEL ? 1 : num_placements,
@@ -213,12 +213,12 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
if (flags & CANCEL)
create.extensions = to_user_pointer(&job_timeout);
- else if (flags & ENGINE_RESET)
+ else if (flags & EXEC_QUEUE_RESET)
create.extensions = to_user_pointer(&preempt_timeout);
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
+ exec_queues[i] = create.exec_queue_id;
syncobjs[i] = syncobj_create(fd, 0);
};
exec.num_batch_buffer = flags & PARALLEL ? num_placements : 1;
@@ -226,7 +226,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
sync[0].handle = syncobj_create(fd, 0);
xe_vm_bind_async(fd, vm, 0, bo, 0, addr, bo_size, sync, 1);
- if (flags & VIRTUAL && (flags & CAT_ERROR || flags & ENGINE_RESET ||
+ if (flags & VIRTUAL && (flags & CAT_ERROR || flags & EXEC_QUEUE_RESET ||
flags & GT_RESET))
bad_batches = num_placements;
@@ -241,7 +241,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
uint64_t sdi_addr = base_addr + sdi_offset;
uint64_t exec_addr;
uint64_t batches[MAX_INSTANCE];
- int e = i % n_engines;
+ int e = i % n_exec_queues;
for (j = 0; j < num_placements && flags & PARALLEL; ++j)
batches[j] = batch_addr;
@@ -268,7 +268,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = flags & PARALLEL ?
to_user_pointer(batches) : exec_addr;
if (e != i)
@@ -280,9 +280,9 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
xe_force_gt_reset(fd, gt);
if (flags & CLOSE_FD) {
- if (flags & CLOSE_ENGINES) {
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ if (flags & CLOSE_EXEC_QUEUES) {
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
drm_close_driver(fd);
/* FIXME: wait for idle */
@@ -290,7 +290,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
return;
}
- for (i = 0; i < n_engines && n_execs; i++)
+ for (i = 0; i < n_exec_queues && n_execs; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -303,9 +303,9 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
igt_assert_eq(data[i].data, 0xc0ffee);
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
munmap(data, bo_size);
@@ -318,8 +318,8 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
* Description: Test cancel
* Run type: FULL
*
- * SUBTEST: engine-reset
- * Description: Test engine reset
+ * SUBTEST: execqueue-reset
+ * Description: Test exec_queue reset
* Run type: FULL
*
* SUBTEST: cat-error
@@ -338,14 +338,14 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
* Description: Test close fd
* Run type: FULL
*
- * SUBTEST: close-engines-close-fd
- * Description: Test close engines close fd
+ * SUBTEST: close-execqueues-close-fd
+ * Description: Test close exec_queues close fd
* Run type: FULL
*/
static void
test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, unsigned int flags)
+ int n_exec_queues, int n_execs, unsigned int flags)
{
uint32_t vm;
uint64_t addr = 0x1a0000;
@@ -358,8 +358,8 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXECQUEUES];
+ uint32_t syncobjs[MAX_N_EXECQUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -370,7 +370,7 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
} *data;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXECQUEUES);
if (flags & CLOSE_FD)
fd = drm_open_driver(DRIVER_XE);
@@ -384,27 +384,27 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
visible_vram_if_possible(fd, eci->gt_id));
data = xe_bo_map(fd, bo, bo_size);
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property job_timeout = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property job_timeout = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_JOB_TIMEOUT,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_JOB_TIMEOUT,
.value = 50,
};
- struct drm_xe_ext_engine_set_property preempt_timeout = {
+ struct drm_xe_ext_exec_queue_set_property preempt_timeout = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_PREEMPTION_TIMEOUT,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_PREEMPTION_TIMEOUT,
.value = 1000,
};
uint64_t ext = 0;
if (flags & CANCEL)
ext = to_user_pointer(&job_timeout);
- else if (flags & ENGINE_RESET)
+ else if (flags & EXEC_QUEUE_RESET)
ext = to_user_pointer(&preempt_timeout);
- engines[i] = xe_engine_create(fd, vm, eci, ext);
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, ext);
syncobjs[i] = syncobj_create(fd, 0);
};
@@ -421,7 +421,7 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = base_addr + sdi_offset;
uint64_t exec_addr;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
if (!i) {
xe_spin_init(&data[i].spin, spin_addr, false);
@@ -442,7 +442,7 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = exec_addr;
if (e != i)
syncobj_reset(fd, &syncobjs[e], 1);
@@ -453,9 +453,9 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
xe_force_gt_reset(fd, eci->gt_id);
if (flags & CLOSE_FD) {
- if (flags & CLOSE_ENGINES) {
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ if (flags & CLOSE_EXEC_QUEUES) {
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
drm_close_driver(fd);
/* FIXME: wait for idle */
@@ -463,7 +463,7 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
return;
}
- for (i = 0; i < n_engines && n_execs; i++)
+ for (i = 0; i < n_exec_queues && n_execs; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -476,9 +476,9 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert_eq(data[i].data, 0xc0ffee);
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
munmap(data, bo_size);
@@ -487,8 +487,8 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
}
/**
- * SUBTEST: cm-engine-reset
- * Description: Test compute mode engine reset
+ * SUBTEST: cm-execqueue-reset
+ * Description: Test compute mode exec_queue reset
* Run type: FULL
*
* SUBTEST: cm-cat-error
@@ -507,14 +507,14 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
* Description: Test compute mode close fd
* Run type: FULL
*
- * SUBTEST: cm-close-engines-close-fd
- * Description: Test compute mode close engines close fd
+ * SUBTEST: cm-close-execqueues-close-fd
+ * Description: Test compute mode close exec_queues close fd
* Run type: FULL
*/
static void
test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, unsigned int flags)
+ int n_exec_queues, int n_execs, unsigned int flags)
{
uint32_t vm;
uint64_t addr = 0x1a0000;
@@ -528,7 +528,7 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXECQUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -541,7 +541,7 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
} *data;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXECQUEUES);
if (flags & CLOSE_FD)
fd = drm_open_driver(DRIVER_XE);
@@ -557,27 +557,27 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
data = xe_bo_map(fd, bo, bo_size);
memset(data, 0, bo_size);
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property compute = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property compute = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
- struct drm_xe_ext_engine_set_property preempt_timeout = {
+ struct drm_xe_ext_exec_queue_set_property preempt_timeout = {
.base.next_extension = to_user_pointer(&compute),
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_PREEMPTION_TIMEOUT,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_PREEMPTION_TIMEOUT,
.value = 1000,
};
uint64_t ext = 0;
- if (flags & ENGINE_RESET)
+ if (flags & EXEC_QUEUE_RESET)
ext = to_user_pointer(&preempt_timeout);
else
ext = to_user_pointer(&compute);
- engines[i] = xe_engine_create(fd, vm, eci, ext);
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, ext);
};
sync[0].addr = to_user_pointer(&data[0].vm_sync);
@@ -597,7 +597,7 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = base_addr + sdi_offset;
uint64_t exec_addr;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
if (!i) {
xe_spin_init(&data[i].spin, spin_addr, false);
@@ -617,7 +617,7 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].addr = base_addr +
(char *)&data[i].exec_sync - (char *)data;
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = exec_addr;
xe_exec(fd, &exec);
}
@@ -626,9 +626,9 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
xe_force_gt_reset(fd, eci->gt_id);
if (flags & CLOSE_FD) {
- if (flags & CLOSE_ENGINES) {
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ if (flags & CLOSE_EXEC_QUEUES) {
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
drm_close_driver(fd);
/* FIXME: wait for idle */
@@ -647,8 +647,8 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
for (i = 1; i < n_execs; i++)
igt_assert_eq(data[i].data, 0xc0ffee);
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
munmap(data, bo_size);
gem_close(fd, bo);
@@ -697,7 +697,7 @@ static void submit_jobs(struct gt_thread_data *t)
.engine_instance = 0,
.gt_id = 0,
};
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = 1,
.num_placements = 1,
@@ -707,15 +707,15 @@ static void submit_jobs(struct gt_thread_data *t)
int ret;
/* GuC IDs can get exhausted */
- ret = igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE, &create);
+ ret = igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, &create);
if (ret)
continue;
- exec.engine_id = create.engine_id;
+ exec.exec_queue_id = create.exec_queue_id;
exec.address = addr;
exec.num_batch_buffer = 1;
xe_exec(fd, &exec);
- xe_engine_destroy(fd, create.engine_id);
+ xe_exec_queue_destroy(fd, create.exec_queue_id);
}
munmap(data, bo_size);
@@ -817,9 +817,9 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
test_legacy_mode(fd, hwe, 1, 1, CANCEL);
- igt_subtest("engine-reset")
+ igt_subtest("execqueue-reset")
xe_for_each_hw_engine(fd, hwe)
- test_legacy_mode(fd, hwe, 2, 2, ENGINE_RESET);
+ test_legacy_mode(fd, hwe, 2, 2, EXEC_QUEUE_RESET);
igt_subtest("cat-error")
xe_for_each_hw_engine(fd, hwe)
@@ -837,14 +837,14 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
test_legacy_mode(-1, hwe, 16, 256, CLOSE_FD);
- igt_subtest("close-engines-close-fd")
+ igt_subtest("close-execqueues-close-fd")
xe_for_each_hw_engine(fd, hwe)
test_legacy_mode(-1, hwe, 16, 256, CLOSE_FD |
- CLOSE_ENGINES);
+ CLOSE_EXEC_QUEUES);
- igt_subtest("cm-engine-reset")
+ igt_subtest("cm-execqueue-reset")
xe_for_each_hw_engine(fd, hwe)
- test_compute_mode(fd, hwe, 2, 2, ENGINE_RESET);
+ test_compute_mode(fd, hwe, 2, 2, EXEC_QUEUE_RESET);
igt_subtest("cm-cat-error")
xe_for_each_hw_engine(fd, hwe)
@@ -862,10 +862,10 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
test_compute_mode(-1, hwe, 16, 256, CLOSE_FD);
- igt_subtest("cm-close-engines-close-fd")
+ igt_subtest("cm-close-execqueues-close-fd")
xe_for_each_hw_engine(fd, hwe)
test_compute_mode(-1, hwe, 16, 256, CLOSE_FD |
- CLOSE_ENGINES);
+ CLOSE_EXEC_QUEUES);
for (const struct section *s = sections; s->name; s++) {
igt_subtest_f("%s-cancel", s->name)
@@ -874,12 +874,12 @@ igt_main
test_balancer(fd, gt, class, 1, 1,
CANCEL | s->flags);
- igt_subtest_f("%s-engine-reset", s->name)
+ igt_subtest_f("%s-execqueue-reset", s->name)
xe_for_each_gt(fd, gt)
xe_for_each_hw_engine_class(class)
test_balancer(fd, gt, class, MAX_INSTANCE + 1,
MAX_INSTANCE + 1,
- ENGINE_RESET | s->flags);
+ EXEC_QUEUE_RESET | s->flags);
igt_subtest_f("%s-cat-error", s->name)
xe_for_each_gt(fd, gt)
@@ -907,11 +907,11 @@ igt_main
test_balancer(-1, gt, class, 16, 256,
CLOSE_FD | s->flags);
- igt_subtest_f("%s-close-engines-close-fd", s->name)
+ igt_subtest_f("%s-close-execqueues-close-fd", s->name)
xe_for_each_gt(fd, gt)
xe_for_each_hw_engine_class(class)
test_balancer(-1, gt, class, 16, 256, CLOSE_FD |
- CLOSE_ENGINES | s->flags);
+ CLOSE_EXEC_QUEUES | s->flags);
}
igt_subtest("gt-reset-stress")
diff --git a/tests/xe/xe_exec_store.c b/tests/xe/xe_exec_store.c
index fbce1aecc..bab5ea5bc 100644
--- a/tests/xe/xe_exec_store.c
+++ b/tests/xe/xe_exec_store.c
@@ -66,7 +66,7 @@ static void store(int fd)
struct data *data;
struct drm_xe_engine_class_instance *hw_engine;
uint32_t vm;
- uint32_t engine;
+ uint32_t exec_queue;
uint32_t syncobj;
size_t bo_size;
int value = 0x123456;
@@ -89,8 +89,8 @@ static void store(int fd)
data = xe_bo_map(fd, bo, bo_size);
store_dword_batch(data, addr, value);
- engine = xe_engine_create(fd, vm, hw_engine, 0);
- exec.engine_id = engine;
+ exec_queue = xe_exec_queue_create(fd, vm, hw_engine, 0);
+ exec.exec_queue_id = exec_queue;
exec.address = data->addr;
sync.flags &= DRM_XE_SYNC_SIGNAL;
xe_exec(fd, &exec);
@@ -102,7 +102,7 @@ static void store(int fd)
munmap(data, bo_size);
gem_close(fd, bo);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
xe_vm_destroy(fd, vm);
}
@@ -125,7 +125,7 @@ static void store_all(int fd, int gt, int class)
struct data *data;
uint32_t syncobjs[MAX_INSTANCE];
- uint32_t engines[MAX_INSTANCE];
+ uint32_t exec_queues[MAX_INSTANCE];
uint32_t vm;
size_t bo_size;
uint64_t addr = 0x100000;
@@ -152,16 +152,16 @@ static void store_all(int fd, int gt, int class)
igt_require(num_placements);
for (i = 0; i < num_placements; i++) {
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = 1,
.num_placements = num_placements,
.instances = to_user_pointer(eci),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
+ exec_queues[i] = create.exec_queue_id;
syncobjs[i] = syncobj_create(fd, 0);
};
@@ -175,7 +175,7 @@ static void store_all(int fd, int gt, int class)
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[i];
- exec.engine_id = engines[i];
+ exec.exec_queue_id = exec_queues[i];
exec.address = data->addr;
xe_exec(fd, &exec);
@@ -190,7 +190,7 @@ static void store_all(int fd, int gt, int class)
for (i = 0; i < num_placements; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
xe_vm_destroy(fd, vm);
}
diff --git a/tests/xe/xe_exec_threads.c b/tests/xe/xe_exec_threads.c
index 396398984..e64c1639a 100644
--- a/tests/xe/xe_exec_threads.c
+++ b/tests/xe/xe_exec_threads.c
@@ -23,7 +23,7 @@
#include "xe/xe_spin.h"
#include <string.h>
-#define MAX_N_ENGINES 16
+#define MAX_N_EXEC_QUEUES 16
#define MAX_INSTANCE 9
#define USERPTR (0x1 << 0)
#define REBIND (0x1 << 1)
@@ -38,25 +38,25 @@
#define VIRTUAL (0x1 << 10)
#define HANG (0x1 << 11)
#define REBIND_ERROR (0x1 << 12)
-#define BIND_ENGINE (0x1 << 13)
+#define BIND_EXEC_QUEUE (0x1 << 13)
pthread_barrier_t barrier;
static void
test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
- int class, int n_engines, int n_execs, unsigned int flags)
+ int class, int n_exec_queues, int n_execs, unsigned int flags)
{
struct drm_xe_sync sync[2] = {
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
};
- struct drm_xe_sync sync_all[MAX_N_ENGINES];
+ struct drm_xe_sync sync_all[MAX_N_EXEC_QUEUES];
struct drm_xe_exec exec = {
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -69,7 +69,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
int i, j, b, num_placements = 0;
bool owns_vm = false, owns_fd = false;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
if (!fd) {
fd = drm_open_driver(DRIVER_XE);
@@ -113,17 +113,17 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
memset(data, 0, bo_size);
memset(sync_all, 0, sizeof(sync_all));
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_engine_create create = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = flags & PARALLEL ? num_placements : 1,
.num_placements = flags & PARALLEL ? 1 : num_placements,
.instances = to_user_pointer(eci),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
+ exec_queues[i] = create.exec_queue_id;
syncobjs[i] = syncobj_create(fd, 0);
sync_all[i].flags = DRM_XE_SYNC_SYNCOBJ;
sync_all[i].handle = syncobjs[i];
@@ -145,7 +145,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
uint64_t batches[MAX_INSTANCE];
- int e = i % n_engines;
+ int e = i % n_exec_queues;
for (j = 0; j < num_placements && flags & PARALLEL; ++j)
batches[j] = batch_addr;
@@ -162,7 +162,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = flags & PARALLEL ?
to_user_pointer(batches) : batch_addr;
if (e != i)
@@ -171,7 +171,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
if (flags & REBIND && i && !(i & 0x1f)) {
xe_vm_unbind_async(fd, vm, 0, 0, addr, bo_size,
- sync_all, n_engines);
+ sync_all, n_exec_queues);
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
addr += bo_size;
@@ -193,7 +193,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
* physical memory on next mmap call triggering
* an invalidate.
*/
- for (j = 0; j < n_engines; ++j)
+ for (j = 0; j < n_exec_queues; ++j)
igt_assert(syncobj_wait(fd,
&syncobjs[j], 1,
INT64_MAX, 0,
@@ -216,7 +216,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
}
}
- for (i = 0; i < n_engines; i++)
+ for (i = 0; i < n_exec_queues; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -230,9 +230,9 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
igt_assert_eq(data[i].data, 0xc0ffee);
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
if (bo) {
@@ -250,7 +250,7 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
static void
test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, unsigned int flags)
+ int n_exec_queues, int n_execs, unsigned int flags)
{
#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
struct drm_xe_sync sync[1] = {
@@ -263,7 +263,7 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
.syncs = to_user_pointer(sync),
};
int64_t fence_timeout;
- uint32_t engines[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -277,7 +277,7 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
int map_fd = -1;
bool owns_vm = false, owns_fd = false;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
if (!fd) {
fd = drm_open_driver(DRIVER_XE);
@@ -286,7 +286,7 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
if (!vm) {
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS |
- XE_ENGINE_SET_PROPERTY_COMPUTE_MODE, 0);
+ XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE, 0);
owns_vm = true;
}
@@ -313,15 +313,15 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
}
memset(data, 0, bo_size);
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property ext = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property ext = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
- engines[i] = xe_engine_create(fd, vm, eci,
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci,
to_user_pointer(&ext));
};
@@ -346,7 +346,7 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -358,7 +358,7 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
sync[0].addr = addr + (char *)&data[i].exec_sync - (char *)data;
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -442,8 +442,8 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
for (i = j; i < n_execs; i++)
igt_assert_eq(data[i].data, 0xc0ffee);
- for (i = 0; i < n_engines; i++)
- xe_engine_destroy(fd, engines[i]);
+ for (i = 0; i < n_exec_queues; i++)
+ xe_exec_queue_destroy(fd, exec_queues[i]);
if (bo) {
munmap(data, bo_size);
@@ -462,22 +462,22 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
static void
test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
- struct drm_xe_engine_class_instance *eci, int n_engines,
+ struct drm_xe_engine_class_instance *eci, int n_exec_queues,
int n_execs, int rebind_error_inject, unsigned int flags)
{
struct drm_xe_sync sync[2] = {
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
};
- struct drm_xe_sync sync_all[MAX_N_ENGINES];
+ struct drm_xe_sync sync_all[MAX_N_EXEC_QUEUES];
struct drm_xe_exec exec = {
.num_batch_buffer = 1,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t bind_engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t bind_exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -486,10 +486,10 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
uint64_t pad;
uint32_t data;
} *data;
- int i, j, b, hang_engine = n_engines / 2;
+ int i, j, b, hang_exec_queue = n_exec_queues / 2;
bool owns_vm = false, owns_fd = false;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
if (!fd) {
fd = drm_open_driver(DRIVER_XE);
@@ -525,23 +525,23 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
memset(data, 0, bo_size);
memset(sync_all, 0, sizeof(sync_all));
- for (i = 0; i < n_engines; i++) {
- struct drm_xe_ext_engine_set_property preempt_timeout = {
+ for (i = 0; i < n_exec_queues; i++) {
+ struct drm_xe_ext_exec_queue_set_property preempt_timeout = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_PREEMPTION_TIMEOUT,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_PREEMPTION_TIMEOUT,
.value = 1000,
};
uint64_t ext = to_user_pointer(&preempt_timeout);
- if (flags & HANG && i == hang_engine)
- engines[i] = xe_engine_create(fd, vm, eci, ext);
+ if (flags & HANG && i == hang_exec_queue)
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, ext);
else
- engines[i] = xe_engine_create(fd, vm, eci, 0);
- if (flags & BIND_ENGINE)
- bind_engines[i] = xe_bind_engine_create(fd, vm, 0);
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
+ if (flags & BIND_EXEC_QUEUE)
+ bind_exec_queues[i] = xe_bind_exec_queue_create(fd, vm, 0);
else
- bind_engines[i] = 0;
+ bind_exec_queues[i] = 0;
syncobjs[i] = syncobj_create(fd, 0);
sync_all[i].flags = DRM_XE_SYNC_SYNCOBJ;
sync_all[i].handle = syncobjs[i];
@@ -551,10 +551,10 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
sync[0].handle = syncobj_create(fd, 0);
if (bo)
- xe_vm_bind_async(fd, vm, bind_engines[0], bo, 0, addr,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0], bo, 0, addr,
bo_size, sync, 1);
else
- xe_vm_bind_userptr_async(fd, vm, bind_engines[0],
+ xe_vm_bind_userptr_async(fd, vm, bind_exec_queues[0],
to_user_pointer(data), addr,
bo_size, sync, 1);
@@ -566,9 +566,9 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
uint64_t exec_addr;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
- if (flags & HANG && e == hang_engine && i == e) {
+ if (flags & HANG && e == hang_exec_queue && i == e) {
xe_spin_init(&data[i].spin, spin_addr, false);
exec_addr = spin_addr;
} else {
@@ -587,11 +587,11 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = exec_addr;
if (e != i && !(flags & HANG))
syncobj_reset(fd, &syncobjs[e], 1);
- if ((flags & HANG && e == hang_engine) ||
+ if ((flags & HANG && e == hang_exec_queue) ||
rebind_error_inject > 0) {
int err;
@@ -606,25 +606,25 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
(!(i & 0x1f) || rebind_error_inject == i)) {
#define INJECT_ERROR (0x1 << 31)
if (rebind_error_inject == i)
- __xe_vm_bind_assert(fd, vm, bind_engines[e],
+ __xe_vm_bind_assert(fd, vm, bind_exec_queues[e],
0, 0, addr, bo_size,
XE_VM_BIND_OP_UNMAP |
XE_VM_BIND_FLAG_ASYNC |
INJECT_ERROR, sync_all,
- n_engines, 0, 0);
+ n_exec_queues, 0, 0);
else
- xe_vm_unbind_async(fd, vm, bind_engines[e],
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[e],
0, addr, bo_size,
- sync_all, n_engines);
+ sync_all, n_exec_queues);
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
addr += bo_size;
if (bo)
- xe_vm_bind_async(fd, vm, bind_engines[e],
+ xe_vm_bind_async(fd, vm, bind_exec_queues[e],
bo, 0, addr, bo_size, sync, 1);
else
xe_vm_bind_userptr_async(fd, vm,
- bind_engines[e],
+ bind_exec_queues[e],
to_user_pointer(data),
addr, bo_size, sync,
1);
@@ -638,12 +638,12 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
* physical memory on next mmap call triggering
* an invalidate.
*/
- for (j = 0; j < n_engines; ++j)
+ for (j = 0; j < n_exec_queues; ++j)
igt_assert(syncobj_wait(fd,
&syncobjs[j], 1,
INT64_MAX, 0,
NULL));
- if (!(flags & HANG && e == hang_engine))
+ if (!(flags & HANG && e == hang_exec_queue))
igt_assert_eq(data[i].data, 0xc0ffee);
} else if (i * 2 != n_execs) {
/*
@@ -662,32 +662,32 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
}
}
- for (i = 0; i < n_engines; i++)
+ for (i = 0; i < n_exec_queues; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
- xe_vm_unbind_async(fd, vm, bind_engines[0], 0, addr,
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[0], 0, addr,
bo_size, sync, 1);
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
for (i = flags & INVALIDATE ? n_execs - 1 : 0;
i < n_execs; i++) {
- int e = i % n_engines;
+ int e = i % n_exec_queues;
- if (flags & HANG && e == hang_engine)
+ if (flags & HANG && e == hang_exec_queue)
igt_assert_eq(data[i].data, 0x0);
else
igt_assert_eq(data[i].data, 0xc0ffee);
}
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
}
if (bo) {
@@ -714,7 +714,7 @@ struct thread_data {
uint32_t vm_legacy_mode;
uint32_t vm_compute_mode;
struct drm_xe_engine_class_instance *eci;
- int n_engine;
+ int n_exec_queue;
int n_exec;
int flags;
int rebind_error_inject;
@@ -732,15 +732,15 @@ static void *thread(void *data)
if (t->flags & PARALLEL || t->flags & VIRTUAL)
test_balancer(t->fd, t->gt, t->vm_legacy_mode, t->addr,
- t->userptr, t->class, t->n_engine, t->n_exec,
+ t->userptr, t->class, t->n_exec_queue, t->n_exec,
t->flags);
else if (t->flags & COMPUTE_MODE)
test_compute_mode(t->fd, t->vm_compute_mode, t->addr,
- t->userptr, t->eci, t->n_engine, t->n_exec,
+ t->userptr, t->eci, t->n_exec_queue, t->n_exec,
t->flags);
else
test_legacy_mode(t->fd, t->vm_legacy_mode, t->addr, t->userptr,
- t->eci, t->n_engine, t->n_exec,
+ t->eci, t->n_exec_queue, t->n_exec,
t->rebind_error_inject, t->flags);
return NULL;
@@ -818,8 +818,8 @@ static void *vm_async_ops_err_thread(void *data)
* userptr
* @rebind:
* rebind
- * @rebind-bindengine:
- * rebind bindengine
+ * @rebind-bindexecqueue:
+ * rebind bindexecqueue
* @userptr-rebind:
* userptr rebind
* @userptr-invalidate:
@@ -830,8 +830,8 @@ static void *vm_async_ops_err_thread(void *data)
* shared vm userptr
* @shared-vm-rebind:
* shared vm rebind
- * @shared-vm-rebind-bindengine:
- * shared vm rebind bindengine
+ * @shared-vm-rebind-bindexecqueue:
+ * shared vm rebind bindexecqueue
* @shared-vm-userptr-rebind:
* shared vm userptr rebind
* @shared-vm-rebind-err:
@@ -1077,7 +1077,7 @@ static void threads(int fd, int flags)
to_user_pointer(&ext));
vm_compute_mode = xe_vm_create(fd,
DRM_XE_VM_CREATE_ASYNC_BIND_OPS |
- XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
0);
vm_err_thread.capture = &capture;
@@ -1101,8 +1101,8 @@ static void threads(int fd, int flags)
threads_data[i].vm_legacy_mode = vm_legacy_mode;
threads_data[i].vm_compute_mode = vm_compute_mode;
threads_data[i].eci = hwe;
-#define N_ENGINE 16
- threads_data[i].n_engine = N_ENGINE;
+#define N_EXEC_QUEUE 16
+ threads_data[i].n_exec_queue = N_EXEC_QUEUE;
#define N_EXEC 1024
threads_data[i].n_exec = N_EXEC;
if (flags & REBIND_ERROR)
@@ -1154,7 +1154,7 @@ static void threads(int fd, int flags)
threads_data[i].vm_legacy_mode =
vm_legacy_mode;
threads_data[i].class = class;
- threads_data[i].n_engine = N_ENGINE;
+ threads_data[i].n_exec_queue = N_EXEC_QUEUE;
threads_data[i].n_exec = N_EXEC;
threads_data[i].flags = flags;
threads_data[i].flags &= ~BALANCER;
@@ -1182,7 +1182,7 @@ static void threads(int fd, int flags)
threads_data[i].vm_legacy_mode =
vm_legacy_mode;
threads_data[i].class = class;
- threads_data[i].n_engine = N_ENGINE;
+ threads_data[i].n_exec_queue = N_EXEC_QUEUE;
threads_data[i].n_exec = N_EXEC;
threads_data[i].flags = flags;
threads_data[i].flags &= ~BALANCER;
@@ -1226,15 +1226,15 @@ igt_main
{ "basic", 0 },
{ "userptr", USERPTR },
{ "rebind", REBIND },
- { "rebind-bindengine", REBIND | BIND_ENGINE },
+ { "rebind-bindexecqueue", REBIND | BIND_EXEC_QUEUE },
{ "userptr-rebind", USERPTR | REBIND },
{ "userptr-invalidate", USERPTR | INVALIDATE },
{ "userptr-invalidate-race", USERPTR | INVALIDATE | RACE },
{ "shared-vm-basic", SHARED_VM },
{ "shared-vm-userptr", SHARED_VM | USERPTR },
{ "shared-vm-rebind", SHARED_VM | REBIND },
- { "shared-vm-rebind-bindengine", SHARED_VM | REBIND |
- BIND_ENGINE },
+ { "shared-vm-rebind-bindexecqueue", SHARED_VM | REBIND |
+ BIND_EXEC_QUEUE },
{ "shared-vm-userptr-rebind", SHARED_VM | USERPTR | REBIND },
{ "shared-vm-rebind-err", SHARED_VM | REBIND | REBIND_ERROR },
{ "shared-vm-userptr-rebind-err", SHARED_VM | USERPTR |
diff --git a/tests/xe/xe_exercise_blt.c b/tests/xe/xe_exercise_blt.c
index 2caed48ff..6d61889b3 100644
--- a/tests/xe/xe_exercise_blt.c
+++ b/tests/xe/xe_exercise_blt.c
@@ -273,15 +273,15 @@ static void fast_copy_test(int xe,
for_each_variation_r(regions, 2, set) {
uint32_t region1, region2;
- uint32_t vm, engine;
+ uint32_t vm, exec_queue;
char *regtxt, *test_name;
region1 = igt_collection_get_value(regions, 0);
region2 = igt_collection_get_value(regions, 1);
vm = xe_vm_create(xe, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engine = xe_engine_create(xe, vm, &inst, 0);
- ctx = intel_ctx_xe(xe, vm, engine, 0, 0, 0);
+ exec_queue = xe_exec_queue_create(xe, vm, &inst, 0);
+ ctx = intel_ctx_xe(xe, vm, exec_queue, 0, 0, 0);
copy_func = (func == FAST_COPY) ? fast_copy : fast_copy_emit;
regtxt = xe_memregion_dynamic_subtest_name(xe, regions);
@@ -295,7 +295,7 @@ static void fast_copy_test(int xe,
free(regtxt);
free(test_name);
- xe_engine_destroy(xe, engine);
+ xe_exec_queue_destroy(xe, exec_queue);
xe_vm_destroy(xe, vm);
free(ctx);
}
diff --git a/tests/xe/xe_guc_pc.c b/tests/xe/xe_guc_pc.c
index 8cdd8ba74..032816921 100644
--- a/tests/xe/xe_guc_pc.c
+++ b/tests/xe/xe_guc_pc.c
@@ -23,7 +23,7 @@
#include <string.h>
#include <sys/time.h>
-#define MAX_N_ENGINES 16
+#define MAX_N_EXEC_QUEUES 16
/*
* Too many intermediate components and steps before freq is adjusted
@@ -32,7 +32,7 @@
#define ACT_FREQ_LATENCY_US 100000
static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs)
+ int n_exec_queues, int n_execs)
{
uint32_t vm;
uint64_t addr = 0x1a0000;
@@ -45,9 +45,9 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t bind_engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t bind_exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -57,7 +57,7 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
} *data;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
igt_assert(n_execs > 0);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
@@ -69,15 +69,15 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
visible_vram_if_possible(fd, eci->gt_id));
data = xe_bo_map(fd, bo, bo_size);
- for (i = 0; i < n_engines; i++) {
- engines[i] = xe_engine_create(fd, vm, eci, 0);
- bind_engines[i] = 0;
+ for (i = 0; i < n_exec_queues; i++) {
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
+ bind_exec_queues[i] = 0;
syncobjs[i] = syncobj_create(fd, 0);
};
sync[0].handle = syncobj_create(fd, 0);
- xe_vm_bind_async(fd, vm, bind_engines[0], bo, 0, addr,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0], bo, 0, addr,
bo_size, sync, 1);
for (i = 0; i < n_execs; i++) {
@@ -85,7 +85,7 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -99,7 +99,7 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
if (e != i)
@@ -115,7 +115,7 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
- xe_vm_unbind_async(fd, vm, bind_engines[0], 0, addr,
+ xe_vm_unbind_async(fd, vm, bind_exec_queues[0], 0, addr,
bo_size, sync, 1);
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -123,11 +123,11 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert_eq(data[i].data, 0xc0ffee);
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
- if (bind_engines[i])
- xe_engine_destroy(fd, bind_engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
}
munmap(data, bo_size);
@@ -212,11 +212,11 @@ static void test_freq_basic_api(int fd, int gt_id)
/**
* SUBTEST: freq_fixed_idle
- * Description: Test fixed frequency request with engine in idle state
+ * Description: Test fixed frequency request with exec_queue in idle state
* Run type: BAT
*
* SUBTEST: freq_fixed_exec
- * Description: Test fixed frequency request when engine is doing some work
+ * Description: Test fixed frequency request when exec_queue is doing some work
* Run type: FULL
*/
@@ -278,11 +278,11 @@ static void test_freq_fixed(int fd, int gt_id, bool gt_idle)
/**
* SUBTEST: freq_range_idle
- * Description: Test range frequency request with engine in idle state
+ * Description: Test range frequency request with exec_queue in idle state
* Run type: BAT
*
* SUBTEST: freq_range_exec
- * Description: Test range frequency request when engine is doing some work
+ * Description: Test range frequency request when exec_queue is doing some work
* Run type: FULL
*/
@@ -421,7 +421,7 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
igt_fork(child, ncpus) {
igt_debug("Execution Started\n");
- exec_basic(fd, hwe, MAX_N_ENGINES, 16);
+ exec_basic(fd, hwe, MAX_N_EXEC_QUEUES, 16);
igt_debug("Execution Finished\n");
}
/* While exec in threads above, let's check the freq */
@@ -442,7 +442,7 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
igt_fork(child, ncpus) {
igt_debug("Execution Started\n");
- exec_basic(fd, hwe, MAX_N_ENGINES, 16);
+ exec_basic(fd, hwe, MAX_N_EXEC_QUEUES, 16);
igt_debug("Execution Finished\n");
}
/* While exec in threads above, let's check the freq */
diff --git a/tests/xe/xe_huc_copy.c b/tests/xe/xe_huc_copy.c
index d4377f9a1..cbc30a8f6 100644
--- a/tests/xe/xe_huc_copy.c
+++ b/tests/xe/xe_huc_copy.c
@@ -107,7 +107,7 @@ gen12_create_batch_huc_copy(uint32_t *batch,
static void
test_huc_copy(int fd)
{
- uint32_t vm, engine;
+ uint32_t vm, exec_queue;
char *dinput;
struct drm_xe_sync sync = { 0 };
@@ -119,7 +119,7 @@ test_huc_copy(int fd)
};
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- engine = xe_engine_create_class(fd, vm, DRM_XE_ENGINE_CLASS_VIDEO_DECODE);
+ exec_queue = xe_exec_queue_create_class(fd, vm, DRM_XE_ENGINE_CLASS_VIDEO_DECODE);
sync.flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL;
sync.handle = syncobj_create(fd, 0);
@@ -136,7 +136,7 @@ test_huc_copy(int fd)
}
gen12_create_batch_huc_copy(bo_dict[2].data, bo_dict[0].addr, bo_dict[1].addr);
- xe_exec_wait(fd, engine, ADDR_BATCH);
+ xe_exec_wait(fd, exec_queue, ADDR_BATCH);
for(int i = 0; i < SIZE_DATA; i++) {
igt_assert(((char*) bo_dict[1].data)[i] == ((char*) bo_dict[0].data)[i]);
}
@@ -148,7 +148,7 @@ test_huc_copy(int fd)
}
syncobj_destroy(fd, sync.handle);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
xe_vm_destroy(fd, vm);
}
diff --git a/tests/xe/xe_intel_bb.c b/tests/xe/xe_intel_bb.c
index 539f44a0f..a5531cf80 100644
--- a/tests/xe/xe_intel_bb.c
+++ b/tests/xe/xe_intel_bb.c
@@ -195,7 +195,7 @@ static void simple_bb(struct buf_ops *bops, bool new_context)
if (new_context) {
vm = xe_vm_create(xe, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- ctx = xe_engine_create(xe, vm, xe_hw_engine(xe, 0), 0);
+ ctx = xe_exec_queue_create(xe, vm, xe_hw_engine(xe, 0), 0);
intel_bb_destroy(ibb);
ibb = intel_bb_create_with_context(xe, ctx, vm, NULL, PAGE_SIZE);
intel_bb_out(ibb, MI_BATCH_BUFFER_END);
@@ -203,7 +203,7 @@ static void simple_bb(struct buf_ops *bops, bool new_context)
intel_bb_exec(ibb, intel_bb_offset(ibb),
I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC,
true);
- xe_engine_destroy(xe, ctx);
+ xe_exec_queue_destroy(xe, ctx);
xe_vm_destroy(xe, vm);
}
diff --git a/tests/xe/xe_noexec_ping_pong.c b/tests/xe/xe_noexec_ping_pong.c
index 49cf11fa6..cc61a77c1 100644
--- a/tests/xe/xe_noexec_ping_pong.c
+++ b/tests/xe/xe_noexec_ping_pong.c
@@ -24,7 +24,7 @@
*
* SUBTEST:
* Description:
- * This test creates compute vms, binds a couple of bos and an engine each,
+ * This test creates compute vms, binds a couple of bos and an exec_queue each,
* thus redying it for execution. However, VRAM memory is over-
* committed and while there is still nothing to execute, an eviction
* will trigger the VM's rebind worker to rebind the evicted bo, which
@@ -34,7 +34,7 @@
* the rebind kworkers using a lot of CPU while the test idles.
*
* The correct driver behaviour should be not to rebind anything unless
- * there is worked queued on one of the VM's compute engines.
+ * there is worked queued on one of the VM's compute exec_queues.
* Run type: FULL
*/
static void test_ping_pong(int fd, struct drm_xe_engine_class_instance *eci)
@@ -44,7 +44,7 @@ static void test_ping_pong(int fd, struct drm_xe_engine_class_instance *eci)
size_t bo_size = vram_size / NUM_VMS / NUM_BOS;
uint32_t vm[NUM_VMS];
uint32_t bo[NUM_VMS][NUM_BOS];
- uint32_t engines[NUM_VMS];
+ uint32_t exec_queues[NUM_VMS];
unsigned int i, j;
igt_skip_on(!bo_size);
@@ -58,10 +58,10 @@ static void test_ping_pong(int fd, struct drm_xe_engine_class_instance *eci)
* stats.
*/
for (i = 0; i < NUM_VMS; ++i) {
- struct drm_xe_ext_engine_set_property ext = {
+ struct drm_xe_ext_exec_queue_set_property ext = {
.base.next_extension = 0,
- .base.name = XE_ENGINE_EXTENSION_SET_PROPERTY,
- .property = XE_ENGINE_SET_PROPERTY_COMPUTE_MODE,
+ .base.name = XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+ .property = XE_EXEC_QUEUE_SET_PROPERTY_COMPUTE_MODE,
.value = 1,
};
@@ -76,7 +76,7 @@ static void test_ping_pong(int fd, struct drm_xe_engine_class_instance *eci)
xe_vm_bind(fd, vm[i], bo[i][j], 0, 0x40000 + j*bo_size,
bo_size, NULL, 0);
}
- engines[i] = xe_engine_create(fd, vm[i], eci,
+ exec_queues[i] = xe_exec_queue_create(fd, vm[i], eci,
to_user_pointer(&ext));
}
@@ -85,7 +85,7 @@ static void test_ping_pong(int fd, struct drm_xe_engine_class_instance *eci)
sleep(SECONDS_TO_WAIT);
for (i = 0; i < NUM_VMS; ++i) {
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
for (j = 0; j < NUM_BOS; ++j)
gem_close(fd, bo[i][j]);
xe_vm_destroy(fd, vm[i]);
diff --git a/tests/xe/xe_pm.c b/tests/xe/xe_pm.c
index 559eccdeb..16af38883 100644
--- a/tests/xe/xe_pm.c
+++ b/tests/xe/xe_pm.c
@@ -25,7 +25,7 @@
#include "xe/xe_ioctl.h"
#include "xe/xe_query.h"
-#define MAX_N_ENGINES 16
+#define MAX_N_EXEC_QUEUES 16
#define NO_SUSPEND -1
#define NO_RPM -1
@@ -208,7 +208,7 @@ static bool out_of_d3(device_t device, enum igt_acpi_d_state state)
static void
test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, enum igt_suspend_state s_state,
+ int n_exec_queues, int n_execs, enum igt_suspend_state s_state,
enum igt_acpi_d_state d_state)
{
uint32_t vm;
@@ -222,9 +222,9 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t bind_engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t bind_exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -236,7 +236,7 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
bool check_rpm = (d_state == IGT_ACPI_D3Hot ||
d_state == IGT_ACPI_D3Cold);
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
igt_assert(n_execs > 0);
if (check_rpm)
@@ -258,15 +258,15 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
visible_vram_if_possible(device.fd_xe, eci->gt_id));
data = xe_bo_map(device.fd_xe, bo, bo_size);
- for (i = 0; i < n_engines; i++) {
- engines[i] = xe_engine_create(device.fd_xe, vm, eci, 0);
- bind_engines[i] = 0;
+ for (i = 0; i < n_exec_queues; i++) {
+ exec_queues[i] = xe_exec_queue_create(device.fd_xe, vm, eci, 0);
+ bind_exec_queues[i] = 0;
syncobjs[i] = syncobj_create(device.fd_xe, 0);
};
sync[0].handle = syncobj_create(device.fd_xe, 0);
- xe_vm_bind_async(device.fd_xe, vm, bind_engines[0], bo, 0, addr,
+ xe_vm_bind_async(device.fd_xe, vm, bind_exec_queues[0], bo, 0, addr,
bo_size, sync, 1);
if (check_rpm && runtime_usage_available(device.pci_xe))
@@ -277,7 +277,7 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i].batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -291,7 +291,7 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
if (e != i)
@@ -315,7 +315,7 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
rpm_usage = igt_pm_get_runtime_usage(device.pci_xe);
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
- xe_vm_unbind_async(device.fd_xe, vm, bind_engines[0], 0, addr,
+ xe_vm_unbind_async(device.fd_xe, vm, bind_exec_queues[0], 0, addr,
bo_size, sync, 1);
igt_assert(syncobj_wait(device.fd_xe, &sync[0].handle, 1, INT64_MAX, 0,
NULL));
@@ -324,11 +324,11 @@ NULL));
igt_assert_eq(data[i].data, 0xc0ffee);
syncobj_destroy(device.fd_xe, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(device.fd_xe, syncobjs[i]);
- xe_engine_destroy(device.fd_xe, engines[i]);
- if (bind_engines[i])
- xe_engine_destroy(device.fd_xe, bind_engines[i]);
+ xe_exec_queue_destroy(device.fd_xe, exec_queues[i]);
+ if (bind_exec_queues[i])
+ xe_exec_queue_destroy(device.fd_xe, bind_exec_queues[i]);
}
munmap(data, bo_size);
diff --git a/tests/xe/xe_spin_batch.c b/tests/xe/xe_spin_batch.c
index 56581f760..26f9daf36 100644
--- a/tests/xe/xe_spin_batch.c
+++ b/tests/xe/xe_spin_batch.c
@@ -41,18 +41,18 @@ static void spin_basic(int fd)
static void spin(int fd, struct drm_xe_engine_class_instance *hwe)
{
uint64_t ahnd;
- unsigned int engine;
+ unsigned int exec_queue;
uint32_t vm;
igt_spin_t *spin;
vm = xe_vm_create(fd, 0, 0);
- engine = xe_engine_create(fd, vm, hwe, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
ahnd = intel_allocator_open(fd, 0, INTEL_ALLOCATOR_RELOC);
- spin = igt_spin_new(fd, .ahnd = ahnd, .engine = engine, .vm = vm);
+ spin = igt_spin_new(fd, .ahnd = ahnd, .engine = exec_queue, .vm = vm);
igt_spin_free(fd, spin);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
xe_vm_destroy(fd, vm);
put_ahnd(ahnd);
@@ -98,7 +98,7 @@ static void spin_basic_all(int fd)
static void spin_all(int fd, int gt, int class)
{
uint64_t ahnd;
- uint32_t engines[MAX_INSTANCE], vm;
+ uint32_t exec_queues[MAX_INSTANCE], vm;
int i, num_placements = 0;
struct drm_xe_engine_class_instance eci[MAX_INSTANCE];
igt_spin_t *spin[MAX_INSTANCE];
@@ -116,22 +116,22 @@ static void spin_all(int fd, int gt, int class)
vm = xe_vm_create(fd, 0, 0);
for (i = 0; i < num_placements; i++) {
- struct drm_xe_engine_create create = {
+ struct drm_xe_exec_queue_create create = {
.vm_id = vm,
.width = 1,
.num_placements = num_placements,
.instances = to_user_pointer(eci),
};
- igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_ENGINE_CREATE,
+ igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE,
&create), 0);
- engines[i] = create.engine_id;
- spin[i] = igt_spin_new(fd, .ahnd = ahnd, .engine = engines[i], .vm = vm);
+ exec_queues[i] = create.exec_queue_id;
+ spin[i] = igt_spin_new(fd, .ahnd = ahnd, .engine = exec_queues[i], .vm = vm);
}
for (i = 0; i < num_placements; i++) {
igt_spin_free(fd, spin[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
put_ahnd(ahnd);
diff --git a/tests/xe/xe_vm.c b/tests/xe/xe_vm.c
index 5703538cc..e42c04e33 100644
--- a/tests/xe/xe_vm.c
+++ b/tests/xe/xe_vm.c
@@ -45,7 +45,7 @@ hash_addr(uint64_t addr)
static void
write_dwords(int fd, uint32_t vm, int n_dwords, uint64_t *addrs)
{
- uint32_t batch_size, batch_bo, *batch_map, engine;
+ uint32_t batch_size, batch_bo, *batch_map, exec_queue;
uint64_t batch_addr = 0x1a0000;
int i, b = 0;
@@ -72,12 +72,12 @@ write_dwords(int fd, uint32_t vm, int n_dwords, uint64_t *addrs)
munmap(batch_map, batch_size);
xe_vm_bind_sync(fd, vm, batch_bo, 0, batch_addr, batch_size);
- engine = xe_engine_create_class(fd, vm, DRM_XE_ENGINE_CLASS_COPY);
- xe_exec_wait(fd, engine, batch_addr);
+ exec_queue = xe_exec_queue_create_class(fd, vm, DRM_XE_ENGINE_CLASS_COPY);
+ xe_exec_wait(fd, exec_queue, batch_addr);
xe_vm_unbind_sync(fd, vm, 0, batch_addr, batch_size);
gem_close(fd, batch_bo);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
}
/**
@@ -515,7 +515,7 @@ struct shared_pte_page_data {
uint32_t data;
};
-#define MAX_N_ENGINES 4
+#define MAX_N_EXEC_QUEUES 4
static void
shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
@@ -527,21 +527,21 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
{ .flags = DRM_XE_SYNC_SYNCOBJ | DRM_XE_SYNC_SIGNAL, },
};
- struct drm_xe_sync sync_all[MAX_N_ENGINES + 1];
+ struct drm_xe_sync sync_all[MAX_N_EXEC_QUEUES + 1];
struct drm_xe_exec exec = {
.num_batch_buffer = 1,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
size_t bo_size;
uint32_t *bo;
struct shared_pte_page_data **data;
- int n_engines = n_bo, n_execs = n_bo;
+ int n_exec_queues = n_bo, n_execs = n_bo;
int i, b;
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
bo = malloc(sizeof(*bo) * n_bo);
igt_assert(bo);
@@ -561,8 +561,8 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
}
memset(sync_all, 0, sizeof(sync_all));
- for (i = 0; i < n_engines; i++) {
- engines[i] = xe_engine_create(fd, vm, eci, 0);
+ for (i = 0; i < n_exec_queues; i++) {
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
syncobjs[i] = syncobj_create(fd, 0);
sync_all[i].flags = DRM_XE_SYNC_SYNCOBJ;
sync_all[i].handle = syncobjs[i];
@@ -579,7 +579,7 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
uint64_t batch_addr = addr + i * addr_stride + batch_offset;
uint64_t sdi_offset = (char *)&data[i]->data - (char *)data[i];
uint64_t sdi_addr = addr + i * addr_stride + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
b = 0;
data[i]->batch[b++] = MI_STORE_DWORD_IMM_GEN4;
@@ -593,7 +593,7 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
}
@@ -624,7 +624,7 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
uint64_t batch_addr = addr + i * addr_stride + batch_offset;
uint64_t sdi_offset = (char *)&data[i]->data - (char *)data[i];
uint64_t sdi_addr = addr + i * addr_stride + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
if (!(i % 2))
continue;
@@ -642,7 +642,7 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
syncobj_reset(fd, &syncobjs[e], 1);
xe_exec(fd, &exec);
@@ -672,9 +672,9 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
igt_assert_eq(data[i]->data, 0xc0ffee);
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
for (i = 0; i < n_bo; ++i) {
@@ -687,21 +687,21 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
/**
- * SUBTEST: bind-engines-independent
- * Description: Test independent bind engines
- * Functionality: bind engines
+ * SUBTEST: bind-execqueues-independent
+ * Description: Test independent bind exec_queues
+ * Functionality: bind exec_queues
* Run type: BAT
*
- * SUBTEST: bind-engines-conflict
- * Description: Test conflict bind engines
- * Functionality: bind engines
+ * SUBTEST: bind-execqueues-conflict
+ * Description: Test conflict bind exec_queues
+ * Functionality: bind exec_queues
* Run type: BAT
*/
#define CONFLICT (0x1 << 0)
static void
-test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
+test_bind_execqueues_independent(int fd, struct drm_xe_engine_class_instance *eci,
unsigned int flags)
{
uint32_t vm;
@@ -715,10 +715,10 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
.num_syncs = 2,
.syncs = to_user_pointer(sync),
};
-#define N_ENGINES 2
- uint32_t engines[N_ENGINES];
- uint32_t bind_engines[N_ENGINES];
- uint32_t syncobjs[N_ENGINES + 1];
+#define N_EXEC_QUEUES 2
+ uint32_t exec_queues[N_EXEC_QUEUES];
+ uint32_t bind_exec_queues[N_EXEC_QUEUES];
+ uint32_t syncobjs[N_EXEC_QUEUES + 1];
size_t bo_size;
uint32_t bo = 0;
struct {
@@ -730,26 +730,26 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
int i, b;
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
- bo_size = sizeof(*data) * N_ENGINES;
+ bo_size = sizeof(*data) * N_EXEC_QUEUES;
bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
xe_get_default_alignment(fd));
bo = xe_bo_create_flags(fd, vm, bo_size,
visible_vram_if_possible(fd, eci->gt_id));
data = xe_bo_map(fd, bo, bo_size);
- for (i = 0; i < N_ENGINES; i++) {
- engines[i] = xe_engine_create(fd, vm, eci, 0);
- bind_engines[i] = xe_bind_engine_create(fd, vm, 0);
+ for (i = 0; i < N_EXEC_QUEUES; i++) {
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
+ bind_exec_queues[i] = xe_bind_exec_queue_create(fd, vm, 0);
syncobjs[i] = syncobj_create(fd, 0);
}
- syncobjs[N_ENGINES] = syncobj_create(fd, 0);
+ syncobjs[N_EXEC_QUEUES] = syncobj_create(fd, 0);
/* Initial bind, needed for spinner */
sync[0].handle = syncobj_create(fd, 0);
- xe_vm_bind_async(fd, vm, bind_engines[0], bo, 0, addr, bo_size,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[0], bo, 0, addr, bo_size,
sync, 1);
- for (i = 0; i < N_ENGINES; i++) {
+ for (i = 0; i < N_EXEC_QUEUES; i++) {
uint64_t batch_offset = (char *)&data[i].batch - (char *)data;
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
@@ -759,9 +759,9 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
int e = i;
if (i == 0) {
- /* Cork 1st engine with a spinner */
+ /* Cork 1st exec_queue with a spinner */
xe_spin_init(&data[i].spin, spin_addr, true);
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = spin_addr;
sync[0].flags &= ~DRM_XE_SYNC_SIGNAL;
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
@@ -769,22 +769,22 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
xe_exec(fd, &exec);
xe_spin_wait_started(&data[i].spin);
- /* Do bind to 1st engine blocked on cork */
+ /* Do bind to 1st exec_queue blocked on cork */
addr += (flags & CONFLICT) ? (0x1 << 21) : bo_size;
sync[1].flags &= ~DRM_XE_SYNC_SIGNAL;
sync[1].handle = syncobjs[e];
- xe_vm_bind_async(fd, vm, bind_engines[e], bo, 0, addr,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[e], bo, 0, addr,
bo_size, sync + 1, 1);
addr += bo_size;
} else {
- /* Do bind to 2nd engine which blocks write below */
+ /* Do bind to 2nd exec_queue which blocks write below */
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
- xe_vm_bind_async(fd, vm, bind_engines[e], bo, 0, addr,
+ xe_vm_bind_async(fd, vm, bind_exec_queues[e], bo, 0, addr,
bo_size, sync, 1);
}
/*
- * Write to either engine, 1st blocked on spinner + bind, 2nd
+ * Write to either exec_queue, 1st blocked on spinner + bind, 2nd
* just blocked on bind. The 2nd should make independent
* progress.
*/
@@ -798,16 +798,16 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
sync[0].flags &= ~DRM_XE_SYNC_SIGNAL;
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
- sync[1].handle = syncobjs[!i ? N_ENGINES : e];
+ sync[1].handle = syncobjs[!i ? N_EXEC_QUEUES : e];
exec.num_syncs = 2;
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
}
if (!(flags & CONFLICT)) {
- /* Verify initial bind, bind + write to 2nd engine done */
+ /* Verify initial bind, bind + write to 2nd exec_queue done */
igt_assert(syncobj_wait(fd, &syncobjs[1], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0,
@@ -816,24 +816,24 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
} else {
/* Let jobs runs for a bit */
usleep(100000);
- /* bind + write to 2nd engine waiting */
+ /* bind + write to 2nd exec_queue waiting */
igt_assert(!syncobj_wait(fd, &syncobjs[1], 1, 1, 0, NULL));
igt_assert(!syncobj_wait(fd, &sync[0].handle, 1, 0, 0, NULL));
}
- /* Verify bind + write to 1st engine still inflight */
+ /* Verify bind + write to 1st exec_queue still inflight */
igt_assert(!syncobj_wait(fd, &syncobjs[0], 1, 1, 0, NULL));
- igt_assert(!syncobj_wait(fd, &syncobjs[N_ENGINES], 1, 1, 0, NULL));
+ igt_assert(!syncobj_wait(fd, &syncobjs[N_EXEC_QUEUES], 1, 1, 0, NULL));
- /* Verify bind + write to 1st engine done after ending spinner */
+ /* Verify bind + write to 1st exec_queue done after ending spinner */
xe_spin_end(&data[0].spin);
igt_assert(syncobj_wait(fd, &syncobjs[0], 1, INT64_MAX, 0, NULL));
- igt_assert(syncobj_wait(fd, &syncobjs[N_ENGINES], 1, INT64_MAX, 0,
+ igt_assert(syncobj_wait(fd, &syncobjs[N_EXEC_QUEUES], 1, INT64_MAX, 0,
NULL));
igt_assert_eq(data[0].data, 0xc0ffee);
if (flags & CONFLICT) {
- /* Verify bind + write to 2nd engine done */
+ /* Verify bind + write to 2nd exec_queue done */
igt_assert(syncobj_wait(fd, &syncobjs[1], 1, INT64_MAX, 0,
NULL));
igt_assert_eq(data[1].data, 0xc0ffee);
@@ -846,10 +846,10 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < N_ENGINES; i++) {
+ for (i = 0; i < N_EXEC_QUEUES; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
- xe_engine_destroy(fd, bind_engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
+ xe_exec_queue_destroy(fd, bind_exec_queues[i]);
}
munmap(data, bo_size);
@@ -857,28 +857,28 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci,
xe_vm_destroy(fd, vm);
}
-#define BIND_ARRAY_BIND_ENGINE_FLAG (0x1 << 0)
+#define BIND_ARRAY_BIND_EXEC_QUEUE_FLAG (0x1 << 0)
/**
* SUBTEST: bind-array-twice
* Description: Test bind array twice
- * Functionality: bind engines
+ * Functionality: bind exec_queues
* Run type: FULL
*
* SUBTEST: bind-array-many
* Description: Test bind array many times
- * Functionality: bind engines
+ * Functionality: bind exec_queues
* Run type: FULL
*
- * SUBTEST: bind-array-engine-twice
- * Description: Test bind array engine twice
- * Functionality: bind engines
+ * SUBTEST: bind-array-exec_queue-twice
+ * Description: Test bind array exec_queue twice
+ * Functionality: bind exec_queues
* Run type: FULL
*
- * SUBTEST: bind-array-engine-many
- * Description: Test bind array engine many times
- * Functionality: bind engines
+ * SUBTEST: bind-array-exec_queue-many
+ * Description: Test bind array exec_queue many times
+ * Functionality: bind exec_queues
* Run type: FULL
*/
static void
@@ -895,7 +895,7 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
.num_batch_buffer = 1,
.syncs = to_user_pointer(sync),
};
- uint32_t engine, bind_engine = 0;
+ uint32_t exec_queue, bind_exec_queue = 0;
#define BIND_ARRAY_MAX_N_EXEC 16
struct drm_xe_vm_bind_op bind_ops[BIND_ARRAY_MAX_N_EXEC] = { };
size_t bo_size;
@@ -918,9 +918,9 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
visible_vram_if_possible(fd, eci->gt_id));
data = xe_bo_map(fd, bo, bo_size);
- if (flags & BIND_ARRAY_BIND_ENGINE_FLAG)
- bind_engine = xe_bind_engine_create(fd, vm, 0);
- engine = xe_engine_create(fd, vm, eci, 0);
+ if (flags & BIND_ARRAY_BIND_EXEC_QUEUE_FLAG)
+ bind_exec_queue = xe_bind_exec_queue_create(fd, vm, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
for (i = 0; i < n_execs; ++i) {
bind_ops[i].obj = bo;
@@ -937,7 +937,7 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
}
sync[0].handle = syncobj_create(fd, 0);
- xe_vm_bind_array(fd, vm, bind_engine, bind_ops, n_execs, sync, 1);
+ xe_vm_bind_array(fd, vm, bind_exec_queue, bind_ops, n_execs, sync, 1);
addr = base_addr;
for (i = 0; i < n_execs; i++) {
@@ -963,7 +963,7 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
exec.num_syncs = 1;
}
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -978,7 +978,7 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
syncobj_reset(fd, &sync[0].handle, 1);
sync[0].flags |= DRM_XE_SYNC_SIGNAL;
sync[1].flags &= ~DRM_XE_SYNC_SIGNAL;
- xe_vm_bind_array(fd, vm, bind_engine, bind_ops, n_execs, sync, 2);
+ xe_vm_bind_array(fd, vm, bind_exec_queue, bind_ops, n_execs, sync, 2);
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
igt_assert(syncobj_wait(fd, &sync[1].handle, 1, INT64_MAX, 0, NULL));
@@ -988,9 +988,9 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
syncobj_destroy(fd, sync[0].handle);
syncobj_destroy(fd, sync[1].handle);
- xe_engine_destroy(fd, engine);
- if (bind_engine)
- xe_engine_destroy(fd, bind_engine);
+ xe_exec_queue_destroy(fd, exec_queue);
+ if (bind_exec_queue)
+ xe_exec_queue_destroy(fd, bind_exec_queue);
munmap(data, bo_size);
gem_close(fd, bo);
@@ -1070,7 +1070,7 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
static void
test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
- int n_engines, int n_execs, size_t bo_size,
+ int n_exec_queues, int n_execs, size_t bo_size,
unsigned int flags)
{
struct drm_xe_sync sync[2] = {
@@ -1084,8 +1084,8 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
};
uint64_t addr = 0x1ull << 30, base_addr = 0x1ull << 30;
uint32_t vm;
- uint32_t engines[MAX_N_ENGINES];
- uint32_t syncobjs[MAX_N_ENGINES];
+ uint32_t exec_queues[MAX_N_EXEC_QUEUES];
+ uint32_t syncobjs[MAX_N_EXEC_QUEUES];
uint32_t bo = 0;
void *map;
struct {
@@ -1100,7 +1100,7 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
base_addr -= xe_get_default_alignment(fd);
}
- igt_assert(n_engines <= MAX_N_ENGINES);
+ igt_assert(n_exec_queues <= MAX_N_EXEC_QUEUES);
vm = xe_vm_create(fd, DRM_XE_VM_CREATE_ASYNC_BIND_OPS, 0);
if (flags & LARGE_BIND_FLAG_USERPTR) {
@@ -1115,8 +1115,8 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
map = xe_bo_map(fd, bo, bo_size);
}
- for (i = 0; i < n_engines; i++) {
- engines[i] = xe_engine_create(fd, vm, eci, 0);
+ for (i = 0; i < n_exec_queues; i++) {
+ exec_queues[i] = xe_exec_queue_create(fd, vm, eci, 0);
syncobjs[i] = syncobj_create(fd, 0);
};
@@ -1147,7 +1147,7 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
uint64_t batch_addr = addr + batch_offset;
uint64_t sdi_offset = (char *)&data[i].data - (char *)data;
uint64_t sdi_addr = addr + sdi_offset;
- int e = i % n_engines;
+ int e = i % n_exec_queues;
data = map + (addr - base_addr);
b = 0;
@@ -1165,7 +1165,7 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
if (i != e)
syncobj_reset(fd, &sync[1].handle, 1);
- exec.engine_id = engines[e];
+ exec.exec_queue_id = exec_queues[e];
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -1175,7 +1175,7 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
addr = base_addr + bo_size - 0x1000;
}
- for (i = 0; i < n_engines; i++)
+ for (i = 0; i < n_exec_queues; i++)
igt_assert(syncobj_wait(fd, &syncobjs[i], 1, INT64_MAX, 0,
NULL));
igt_assert(syncobj_wait(fd, &sync[0].handle, 1, INT64_MAX, 0, NULL));
@@ -1205,9 +1205,9 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
}
syncobj_destroy(fd, sync[0].handle);
- for (i = 0; i < n_engines; i++) {
+ for (i = 0; i < n_exec_queues; i++) {
syncobj_destroy(fd, syncobjs[i]);
- xe_engine_destroy(fd, engines[i]);
+ xe_exec_queue_destroy(fd, exec_queues[i]);
}
if (bo) {
@@ -1246,7 +1246,7 @@ static void *hammer_thread(void *tdata)
uint64_t pad;
uint32_t data;
} *data = t->map;
- uint32_t engine = xe_engine_create(t->fd, t->vm, t->eci, 0);
+ uint32_t exec_queue = xe_exec_queue_create(t->fd, t->vm, t->eci, 0);
int b;
int i = 0;
@@ -1267,7 +1267,7 @@ static void *hammer_thread(void *tdata)
data->batch[b++] = MI_BATCH_BUFFER_END;
igt_assert(b <= ARRAY_SIZE(data->batch));
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
if (i % 32) {
exec.num_syncs = 0;
@@ -1283,7 +1283,7 @@ static void *hammer_thread(void *tdata)
}
syncobj_destroy(t->fd, sync[0].handle);
- xe_engine_destroy(t->fd, engine);
+ xe_exec_queue_destroy(t->fd, exec_queue);
return NULL;
}
@@ -1368,7 +1368,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
};
uint64_t addr = 0x1a00000, base_addr = 0x1a00000;
uint32_t vm;
- uint32_t engine;
+ uint32_t exec_queue;
size_t bo_size;
uint32_t bo = 0;
uint64_t bind_size;
@@ -1408,7 +1408,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
}
memset(map, 0, bo_size);
- engine = xe_engine_create(fd, vm, eci, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
sync[0].handle = syncobj_create(fd, 0);
sync[1].handle = syncobj_create(fd, 0);
@@ -1466,7 +1466,7 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
syncobj_reset(fd, &sync[1].handle, 1);
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -1522,7 +1522,7 @@ try_again_after_invalidate:
syncobj_reset(fd, &sync[1].handle, 1);
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
}
@@ -1593,7 +1593,7 @@ try_again_after_invalidate:
syncobj_reset(fd, &sync[1].handle, 1);
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -1618,7 +1618,7 @@ try_again_after_invalidate:
syncobj_destroy(fd, sync[0].handle);
syncobj_destroy(fd, sync[1].handle);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
munmap(map, bo_size);
if (bo)
gem_close(fd, bo);
@@ -1669,7 +1669,7 @@ test_mmap_style_bind(int fd, struct drm_xe_engine_class_instance *eci,
};
uint64_t addr = 0x1a00000, base_addr = 0x1a00000;
uint32_t vm;
- uint32_t engine;
+ uint32_t exec_queue;
size_t bo_size;
uint32_t bo0 = 0, bo1 = 0;
uint64_t bind_size;
@@ -1714,7 +1714,7 @@ test_mmap_style_bind(int fd, struct drm_xe_engine_class_instance *eci,
memset(map0, 0, bo_size);
memset(map1, 0, bo_size);
- engine = xe_engine_create(fd, vm, eci, 0);
+ exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
sync[0].handle = syncobj_create(fd, 0);
sync[1].handle = syncobj_create(fd, 0);
@@ -1772,7 +1772,7 @@ test_mmap_style_bind(int fd, struct drm_xe_engine_class_instance *eci,
syncobj_reset(fd, &sync[1].handle, 1);
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -1840,7 +1840,7 @@ test_mmap_style_bind(int fd, struct drm_xe_engine_class_instance *eci,
syncobj_reset(fd, &sync[1].handle, 1);
sync[1].flags |= DRM_XE_SYNC_SIGNAL;
- exec.engine_id = engine;
+ exec.exec_queue_id = exec_queue;
exec.address = batch_addr;
xe_exec(fd, &exec);
@@ -1872,7 +1872,7 @@ test_mmap_style_bind(int fd, struct drm_xe_engine_class_instance *eci,
syncobj_destroy(fd, sync[0].handle);
syncobj_destroy(fd, sync[1].handle);
- xe_engine_destroy(fd, engine);
+ xe_exec_queue_destroy(fd, exec_queue);
munmap(map0, bo_size);
munmap(map1, bo_size);
if (bo0)
@@ -2033,13 +2033,13 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
shared_pte_page(fd, hwe, 4, 0x1000ul * 512 * 512 * 512);
- igt_subtest("bind-engines-independent")
+ igt_subtest("bind-execqueues-independent")
xe_for_each_hw_engine(fd, hwe)
- test_bind_engines_independent(fd, hwe, 0);
+ test_bind_execqueues_independent(fd, hwe, 0);
- igt_subtest("bind-engines-conflict")
+ igt_subtest("bind-execqueues-conflict")
xe_for_each_hw_engine(fd, hwe)
- test_bind_engines_independent(fd, hwe, CONFLICT);
+ test_bind_execqueues_independent(fd, hwe, CONFLICT);
igt_subtest("bind-array-twice")
xe_for_each_hw_engine(fd, hwe)
@@ -2049,15 +2049,15 @@ igt_main
xe_for_each_hw_engine(fd, hwe)
test_bind_array(fd, hwe, 16, 0);
- igt_subtest("bind-array-engine-twice")
+ igt_subtest("bind-array-exec_queue-twice")
xe_for_each_hw_engine(fd, hwe)
test_bind_array(fd, hwe, 2,
- BIND_ARRAY_BIND_ENGINE_FLAG);
+ BIND_ARRAY_BIND_EXEC_QUEUE_FLAG);
- igt_subtest("bind-array-engine-many")
+ igt_subtest("bind-array-exec_queue-many")
xe_for_each_hw_engine(fd, hwe)
test_bind_array(fd, hwe, 16,
- BIND_ARRAY_BIND_ENGINE_FLAG);
+ BIND_ARRAY_BIND_EXEC_QUEUE_FLAG);
for (bind_size = 0x1ull << 21; bind_size <= 0x1ull << 31;
bind_size = bind_size << 1) {
--
2.34.1
More information about the igt-dev
mailing list