Skip to contentSkip to conversation

Madvise feature in SVM for Multi-GPU configs

PATCH Superseded [email protected] 4 participants 27 messages Dec 1, 2025 Arm/Amlogic Meson SoC support

v9 of 14 Superseded Latest is v14 →

lore
Share & tools
lore
#0 lore raw

v9 cover Madvise feature in SVM for Multi-GPU configs

From: Nishit Sharma <[email protected]>

This patch series adds comprehensive SVM multi-GPU IGT test coverage for madvise and prefetch functionality.

ver2:
- Test name changed in commits
- In patchwork v1 patch is missing due to last patch was not sent

ver3:
- In patch-7 tags were added and it was not sent on patchwork

ver4:
- In patch file was added which is not available in source which caused CI build failure.

ver5:
- Added subtest function wrappers
- Subtests executing for all GPUs enumerated

ver7:
- Optimized function calling which are frequenctly called
- Incorporated review comments (Thomas Hellstrom)

ver8:
- Incorporated review comments (Thomas Hellstrom)
- Seperated madvise and lr_sync patches
- merged added 0 as instance parameter in xe_vm_madvise() call in xe_exec_system_allocator with xe_vm_madvise lib changes
- Subtests declared in const struct section[] and optimized
- All subtests executed with and without prefetch

ver9:
- Incorporated review comments (Pravalika, Thomas)
- Optimized code. Multiple same function called put in single function
- Added READ_ONCE/WRITE_once instead dereferecing.

Nishit Sharma (10):
lib/xe: Add instance parameter to xe_vm_madvise
lib/xe: Add synchronous helpers for VM bind/unbind operations tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test tests/intel/xe_multi_gpusvm: Add SVM multi-GPU atomic operations tests/intel/xe_multi_gpusvm: Add SVM multi-GPU coherency test tests/intel/xe_multi_gpusvm: Add SVM multi-GPU performance test tests/intel/xe_multi_gpusvm: Add SVM multi-GPU fault handling test tests/intel/xe_multi_gpusvm: Add SVM multi-GPU simultaneous access
test
tests/intel/xe_multi_gpusvm: Add SVM multi-GPU conflicting madvise
test
tests/intel/xe_multi-gpusvm: Add SVM multi-GPU migration test

 include/drm-uapi/xe_drm.h              |    4 +-
 lib/xe/xe_ioctl.c                      |   52 +-
 lib/xe/xe_ioctl.h                      |    9 +-
 tests/intel/xe_exec_system_allocator.c |    8 +-
 tests/intel/xe_multi_gpusvm.c          | 1664 ++++++++++++++++++++++++
 tests/meson.build                      |    1 +
 6 files changed, 1726 insertions(+), 12 deletions(-)
 create mode 100644 tests/intel/xe_multi_gpusvm.c
Signature · 1 line
2.48.1
#1 lore raw

PATCH v9 1/10 lib/xe: Add instance parameter to xe_vm_madvise

From: Nishit Sharma <[email protected]>

tests/intel/xe_exec_system_allocator: Add parameter in madvise call

Add an 'instance' parameter to __xe_vm_madvise() and xe_vm_madvise() to specify which VRAM instance should be targeted for memory advise operations.
Getting compilation issues in xe_exec_system_allocator test after adding 'instance' parameters in xe_vm_madvise(). As a fix 0 as instance parameter passed in xe_vm_madvise() calls available in xe_exec_system_allocator test.

---
 include/drm-uapi/xe_drm.h              |  4 ++--
 lib/xe/xe_ioctl.c                      | 13 +++++++++----
 lib/xe/xe_ioctl.h                      |  9 +++++++--
 tests/intel/xe_exec_system_allocator.c |  8 ++++----
 4 files changed, 22 insertions(+), 12 deletions(-)
include/drm-uapi/xe_drm.h +2 -2
index 89ab54935..3472efa58 100644
@@ -2060,8 +2060,8 @@ struct drm_xe_madvise {
 			/** @preferred_mem_loc.migration_policy: Page migration policy */
 			__u16 migration_policy;
 
-			/** @preferred_mem_loc.pad : MBZ */
-			__u16 pad;
+			/** @preferred_mem_loc.region_instance: Region instance */
+			__u16 region_instance;
 
 			/** @preferred_mem_loc.reserved : Reserved */
 			__u64 reserved;
lib/xe/xe_ioctl.c +9 -4
index 39c4667a1..221fd7c62 100644
@@ -687,7 +687,8 @@ int64_t xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
 }
 
 int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
-		    uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy)
+		    uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy,
+		    uint16_t instance)
 {
 	struct drm_xe_madvise madvise = {
 		.type = type,
@@ -704,6 +705,7 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 	case DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC:
 		madvise.preferred_mem_loc.devmem_fd = op_val;
 		madvise.preferred_mem_loc.migration_policy = policy;
+		madvise.preferred_mem_loc.region_instance = instance;
 		igt_debug("madvise.preferred_mem_loc.devmem_fd = %d\n",
 			  madvise.preferred_mem_loc.devmem_fd);
 		break;
@@ -731,14 +733,17 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
  * @type: type of attribute
  * @op_val: fd/atomic value/pat index, depending upon type of operation
  * @policy: Page migration policy
+ * @instance: vram instance
  *
  * Function initializes different members of struct drm_xe_madvise and calls
  * MADVISE IOCTL .
  *
- * Asserts in case of error returned by DRM_IOCTL_XE_MADVISE.
+ * Asserts in case of error returned by DRM_IOCTL_XE_MADVISE
  */
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
-		   uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy)
+		   uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy,
+		   uint16_t instance)
 {
-	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type, op_val, policy), 0);
+	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type, op_val, policy,
+				      instance), 0);
 }
lib/xe/xe_ioctl.h +7 -2
index ae8a23a54..bbee06a9d 100644
@@ -100,13 +100,18 @@ int __xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
 int64_t xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
 		       uint32_t exec_queue, int64_t timeout);
 int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,
-		    uint32_t type, uint32_t op_val, uint16_t policy);
+		    uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,
-		   uint32_t type, uint32_t op_val, uint16_t policy);
+		   uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
 int xe_vm_number_vmas_in_range(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr);
 int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr,
 		    struct drm_xe_mem_range_attr *mem_attr);
 struct drm_xe_mem_range_attr
 *xe_vm_get_mem_attr_values_in_range(int fd, uint32_t vm, uint64_t start,
 				    uint64_t range, uint32_t *num_ranges);
+void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo,
+			uint64_t offset, uint64_t addr,
+			uint64_t size, uint32_t flags);
+void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
+			  uint64_t addr, uint64_t size);
 #endif /* XE_IOCTL_H */
tests/intel/xe_exec_system_allocator.c +4 -4
index b88967e58..1e7175061 100644
@@ -1164,7 +1164,7 @@ madvise_swizzle_op_exec(int fd, uint32_t vm, struct test_exec_data *data,
 	xe_vm_madvise(fd, vm, to_user_pointer(data), bo_size, 0,
 		      DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
 		      preferred_loc,
-		      0);
+		      0, 0);
 }
 
 static void
@@ -1172,7 +1172,7 @@ xe_vm_madvixe_pat_attr(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 		       int pat_index)
 {
 	xe_vm_madvise(fd, vm, addr, range, 0,
-		      DRM_XE_MEM_RANGE_ATTR_PAT, pat_index, 0);
+		      DRM_XE_MEM_RANGE_ATTR_PAT, pat_index, 0, 0);
 }
 
 static void
@@ -1181,7 +1181,7 @@ xe_vm_madvise_atomic_attr(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 {
 	xe_vm_madvise(fd, vm, addr, range, 0,
 		      DRM_XE_MEM_RANGE_ATTR_ATOMIC,
-		      mem_attr, 0);
+		      mem_attr, 0, 0);
 }
 
 static void
@@ -1190,7 +1190,7 @@ xe_vm_madvise_migrate_pages(int fd, uint32_t vm, uint64_t addr, uint64_t range)
 	xe_vm_madvise(fd, vm, addr, range, 0,
 		      DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
 		      DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM,
-		      DRM_XE_MIGRATE_ALL_PAGES);
+		      DRM_XE_MIGRATE_ALL_PAGES, 0);
 }
 
 static void
Signature · 1 line
2.48.1
Reviewed-by on v9 1/10
#2 lore raw

RE: [PATCH i-g-t v9 01/10] lib/xe: Add instance parameter to xe_vm_madvise

Quoted 173 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 01/10] lib/xe: Add instance parameter to xe_vm_madvise

From: Nishit Sharma <[email protected]>

tests/intel/xe_exec_system_allocator: Add parameter in madvise call

Add an 'instance' parameter to __xe_vm_madvise() and xe_vm_madvise() to specify which VRAM instance should be targeted for memory advise operations.
Getting compilation issues in xe_exec_system_allocator test after adding 'instance' parameters in xe_vm_madvise(). As a fix 0 as instance parameter passed in xe_vm_madvise() calls available in xe_exec_system_allocator test.

---
 include/drm-uapi/xe_drm.h              |  4 ++--
 lib/xe/xe_ioctl.c                      | 13 +++++++++----
 lib/xe/xe_ioctl.h                      |  9 +++++++--
 tests/intel/xe_exec_system_allocator.c |  8 ++++----
 4 files changed, 22 insertions(+), 12 deletions(-)
include/drm-uapi/xe_drm.h index renamed from include/drm-uapi/xe_drm.h +0 -0

89ab54935..3472efa58 100644

include/drm-uapi/xe_drm.h +0 -0
@@ -2060,8 +2060,8 @@ struct drm_xe_madvise {
 			/** @preferred_mem_loc.migration_policy: Page

migration policy */

include/drm-uapi/xe_drm.h +1 -2
 			__u16 migration_policy;
 
-			/** @preferred_mem_loc.pad : MBZ */
-			__u16 pad;
+			/** @preferred_mem_loc.region_instance: Region

instance */

include/drm-uapi/xe_drm.h +1 -0
+			__u16 region_instance;
 
 			/** @preferred_mem_loc.reserved : Reserved */
 			__u64 reserved;
lib/xe/xe_ioctl.c index 39c4667a1..221fd7c62 renamed from lib/xe/xe_ioctl.c +0 -0

100644

lib/xe/xe_ioctl.c +2 -1
@@ -687,7 +687,8 @@ int64_t xe_wait_ufence(int fd, uint64_t *addr,
 uint64_t value,  }
 
 int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
-		    uint64_t ext, uint32_t type, uint32_t op_val, uint16_t
 policy)
+		    uint64_t ext, uint32_t type, uint32_t op_val, uint16_t
 policy,
+		    uint16_t instance)
 {
lib/xe/xe_ioctl.c +1 -0
 	struct drm_xe_madvise madvise = {
 		.type = type,
@@ -704,6 +705,7 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t
 addr, uint64_t range,
 	case DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC:
 		madvise.preferred_mem_loc.devmem_fd = op_val;
 		madvise.preferred_mem_loc.migration_policy = policy;
+		madvise.preferred_mem_loc.region_instance = instance;
 		igt_debug("madvise.preferred_mem_loc.devmem_fd =
 %d\n",
lib/xe/xe_ioctl.c +4 -3
 			  madvise.preferred_mem_loc.devmem_fd);
 		break;
@@ -731,14 +733,17 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t
 addr, uint64_t range,
  * @type: type of attribute
  * @op_val: fd/atomic value/pat index, depending upon type of operation
  * @policy: Page migration policy
+ * @instance: vram instance
  *
  * Function initializes different members of struct drm_xe_madvise and calls
  * MADVISE IOCTL .
  *
- * Asserts in case of error returned by DRM_IOCTL_XE_MADVISE.
+ * Asserts in case of error returned by DRM_IOCTL_XE_MADVISE
  */
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
-		   uint64_t ext, uint32_t type, uint32_t op_val, uint16_t
 policy)
+		   uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy,
+		   uint16_t instance)
 {
-	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type,

op_val, policy), 0);

lib/xe/xe_ioctl.c +1 -0
+	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type,

op_val, policy,

lib/xe/xe_ioctl.c +1 -0
+				      instance), 0);
 }
lib/xe/xe_ioctl.h index ae8a23a54..bbee06a9d renamed from lib/xe/xe_ioctl.h +0 -0

100644

lib/xe/xe_ioctl.h +0 -0
@@ -100,13 +100,18 @@ int __xe_wait_ufence(int fd, uint64_t *addr,

uint64_t value, int64_t xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
uint32_t exec_queue, int64_t timeout); int
__xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,

lib/xe/xe_ioctl.h +2 -1
-		    uint32_t type, uint32_t op_val, uint16_t policy);
+		    uint32_t type, uint32_t op_val, uint16_t policy, uint16_t
+instance);
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,

uint64_t ext,

lib/xe/xe_ioctl.h +2 -1
-		   uint32_t type, uint32_t op_val, uint16_t policy);
+		   uint32_t type, uint32_t op_val, uint16_t policy, uint16_t
+instance);
 int xe_vm_number_vmas_in_range(int fd, struct

drm_xe_vm_query_mem_range_attr *vmas_attr); int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr,
struct drm_xe_mem_range_attr *mem_attr); struct
drm_xe_mem_range_attr *xe_vm_get_mem_attr_values_in_range(int fd, uint32_t vm, uint64_t start,

lib/xe/xe_ioctl.h +5 -0
 				    uint64_t range, uint32_t *num_ranges);
+void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo,
+			uint64_t offset, uint64_t addr,
+			uint64_t size, uint32_t flags);
+void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
+			  uint64_t addr, uint64_t size);
 #endif /* XE_IOCTL_H */
tests/intel/xe_exec_system_allocator.c +1 -1
index b88967e58..1e7175061 100644
@@ -1164,7 +1164,7 @@ madvise_swizzle_op_exec(int fd, uint32_t vm,
 struct test_exec_data *data,
 	xe_vm_madvise(fd, vm, to_user_pointer(data), bo_size, 0,
 		      DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
 		      preferred_loc,
-		      0);
+		      0, 0);
 }
 

static void

tests/intel/xe_exec_system_allocator.c +1 -1
@@ -1172,7 +1172,7 @@ xe_vm_madvixe_pat_attr(int fd, uint32_t vm,
 uint64_t addr, uint64_t range,
 		       int pat_index)
 {
 	xe_vm_madvise(fd, vm, addr, range, 0,
-		      DRM_XE_MEM_RANGE_ATTR_PAT, pat_index, 0);
+		      DRM_XE_MEM_RANGE_ATTR_PAT, pat_index, 0, 0);
 }
 

static void

tests/intel/xe_exec_system_allocator.c +2 -2
@@ -1181,7 +1181,7 @@ xe_vm_madvise_atomic_attr(int fd, uint32_t vm,
 uint64_t addr, uint64_t range,  {
 	xe_vm_madvise(fd, vm, addr, range, 0,
 		      DRM_XE_MEM_RANGE_ATTR_ATOMIC,
-		      mem_attr, 0);
+		      mem_attr, 0, 0);
 }
 
 static void
@@ -1190,7 +1190,7 @@ xe_vm_madvise_migrate_pages(int fd, uint32_t
 vm, uint64_t addr, uint64_t range)
 	xe_vm_madvise(fd, vm, addr, range, 0,
 		      DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
 		      DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM,
-		      DRM_XE_MIGRATE_ALL_PAGES);
+		      DRM_XE_MIGRATE_ALL_PAGES, 0);
 }
 
Quoted 2 lines

static void
--

Quoted 1 line

2.48.1

#3 lore raw

Re: [PATCH i-g-t v9 01/10] lib/xe: Add instance parameter to xe_vm_madvise

In reply to [email protected]

Hi nishit.sharma,

Quoted 11 lines · On 2025-12-01 at 09:03:40 +0000, [email protected] wrote:

From: Nishit Sharma <[email protected]>

tests/intel/xe_exec_system_allocator: Add parameter in madvise call

Add an 'instance' parameter to __xe_vm_madvise() and xe_vm_madvise() to specify which VRAM instance should be targeted for memory advise operations.
Getting compilation issues in xe_exec_system_allocator test after adding 'instance' parameters in xe_vm_madvise(). As a fix 0 as instance parameter passed in xe_vm_madvise() calls available in xe_exec_system_allocator test.

+cc Thomas

Quoted 3 lines
---
 include/drm-uapi/xe_drm.h              |  4 ++--

I said it before - you cannot do it with this commit. First, drm-uapi change should be splitted into a separate change and be in sync with drm-next commit.

Without drm-tip counterpart, you can change include/drm-uapi-experimental/intel_drm_local.h and then you can make it as one commit, in this first patch.
Later on after a upai changes reach drm-next, you can bring them here
and remove stale ones from exeperimental.

For reference look into history:
git log -- include/drm-uapi/xe_drm.h

Regards,
Kamil

Quoted 131 lines
 lib/xe/xe_ioctl.c                      | 13 +++++++++----
 lib/xe/xe_ioctl.h                      |  9 +++++++--
 tests/intel/xe_exec_system_allocator.c |  8 ++++----
 4 files changed, 22 insertions(+), 12 deletions(-)
include/drm-uapi/xe_drm.h +2 -2
index 89ab54935..3472efa58 100644
@@ -2060,8 +2060,8 @@ struct drm_xe_madvise {
 			/** @preferred_mem_loc.migration_policy: Page migration policy */
 			__u16 migration_policy;
 
-			/** @preferred_mem_loc.pad : MBZ */
-			__u16 pad;
+			/** @preferred_mem_loc.region_instance: Region instance */
+			__u16 region_instance;
 
 			/** @preferred_mem_loc.reserved : Reserved */
 			__u64 reserved;
lib/xe/xe_ioctl.c +9 -4
index 39c4667a1..221fd7c62 100644
@@ -687,7 +687,8 @@ int64_t xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
 }
 
 int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
-		    uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy)
+		    uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy,
+		    uint16_t instance)
 {
 	struct drm_xe_madvise madvise = {
 		.type = type,
@@ -704,6 +705,7 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 	case DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC:
 		madvise.preferred_mem_loc.devmem_fd = op_val;
 		madvise.preferred_mem_loc.migration_policy = policy;
+		madvise.preferred_mem_loc.region_instance = instance;
 		igt_debug("madvise.preferred_mem_loc.devmem_fd = %d\n",
 			  madvise.preferred_mem_loc.devmem_fd);
 		break;
@@ -731,14 +733,17 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
  * @type: type of attribute
  * @op_val: fd/atomic value/pat index, depending upon type of operation
  * @policy: Page migration policy
+ * @instance: vram instance
  *
  * Function initializes different members of struct drm_xe_madvise and calls
  * MADVISE IOCTL .
  *
- * Asserts in case of error returned by DRM_IOCTL_XE_MADVISE.
+ * Asserts in case of error returned by DRM_IOCTL_XE_MADVISE
  */
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
-		   uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy)
+		   uint64_t ext, uint32_t type, uint32_t op_val, uint16_t policy,
+		   uint16_t instance)
 {
-	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type, op_val, policy), 0);
+	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type, op_val, policy,
+				      instance), 0);
 }
lib/xe/xe_ioctl.h +7 -2
index ae8a23a54..bbee06a9d 100644
@@ -100,13 +100,18 @@ int __xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
 int64_t xe_wait_ufence(int fd, uint64_t *addr, uint64_t value,
 		       uint32_t exec_queue, int64_t timeout);
 int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,
-		    uint32_t type, uint32_t op_val, uint16_t policy);
+		    uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,
-		   uint32_t type, uint32_t op_val, uint16_t policy);
+		   uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
 int xe_vm_number_vmas_in_range(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr);
 int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr,
 		    struct drm_xe_mem_range_attr *mem_attr);
 struct drm_xe_mem_range_attr
 *xe_vm_get_mem_attr_values_in_range(int fd, uint32_t vm, uint64_t start,
 				    uint64_t range, uint32_t *num_ranges);
+void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo,
+			uint64_t offset, uint64_t addr,
+			uint64_t size, uint32_t flags);
+void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
+			  uint64_t addr, uint64_t size);
 #endif /* XE_IOCTL_H */
tests/intel/xe_exec_system_allocator.c +4 -4
index b88967e58..1e7175061 100644
@@ -1164,7 +1164,7 @@ madvise_swizzle_op_exec(int fd, uint32_t vm, struct test_exec_data *data,
 	xe_vm_madvise(fd, vm, to_user_pointer(data), bo_size, 0,
 		      DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
 		      preferred_loc,
-		      0);
+		      0, 0);
 }
 
 static void
@@ -1172,7 +1172,7 @@ xe_vm_madvixe_pat_attr(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 		       int pat_index)
 {
 	xe_vm_madvise(fd, vm, addr, range, 0,
-		      DRM_XE_MEM_RANGE_ATTR_PAT, pat_index, 0);
+		      DRM_XE_MEM_RANGE_ATTR_PAT, pat_index, 0, 0);
 }
 
 static void
@@ -1181,7 +1181,7 @@ xe_vm_madvise_atomic_attr(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 {
 	xe_vm_madvise(fd, vm, addr, range, 0,
 		      DRM_XE_MEM_RANGE_ATTR_ATOMIC,
-		      mem_attr, 0);
+		      mem_attr, 0, 0);
 }
 
 static void
@@ -1190,7 +1190,7 @@ xe_vm_madvise_migrate_pages(int fd, uint32_t vm, uint64_t addr, uint64_t range)
 	xe_vm_madvise(fd, vm, addr, range, 0,
 		      DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
 		      DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM,
-		      DRM_XE_MIGRATE_ALL_PAGES);
+		      DRM_XE_MIGRATE_ALL_PAGES, 0);
 }
 
 static void
Signature · 1 line
2.48.1
#4 lore raw

PATCH v9 2/10 lib/xe: Add synchronous helpers for VM bind/unbind operations

In reply to [email protected]

From: Nishit Sharma <[email protected]>

Introduce synchronous wrappers for VM bind/unbind operations that handle user fence allocation, waiting, and cleanup internally. This simplifies test code by eliminating repetitive synchronization boilerplate.

---
 lib/xe/xe_ioctl.c | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
lib/xe/xe_ioctl.c +39 -0
index 221fd7c62..369c5887d 100644
@@ -747,3 +747,42 @@ void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type, op_val, policy,
 				      instance), 0);
 }
+
+#define        BIND_SYNC_VAL   0x686868
+void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
+			uint64_t addr, uint64_t size, uint32_t flags)
+{
+	volatile uint64_t *sync_addr = malloc(sizeof(*sync_addr));
+	struct drm_xe_sync sync = {
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.addr = to_user_pointer((uint64_t *)sync_addr),
+		.timeline_value = BIND_SYNC_VAL,
+	};
+
+	igt_assert(!!sync_addr);
+	xe_vm_bind_async_flags(fd, vm, 0, bo, 0, addr, size, &sync, 1, flags);
+	if (*sync_addr != BIND_SYNC_VAL)
+		xe_wait_ufence(fd, (uint64_t *)sync_addr, BIND_SYNC_VAL, 0, NSEC_PER_SEC * 10);
+	/* Only free if the wait succeeds */
+	free((void *)sync_addr);
+}
+
+void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
+			  uint64_t addr, uint64_t size)
+{
+	volatile uint64_t *sync_addr = malloc(sizeof(*sync_addr));
+	struct drm_xe_sync sync = {
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.addr = to_user_pointer((uint64_t *)sync_addr),
+		.timeline_value = BIND_SYNC_VAL,
+	};
+
+	igt_assert(!!sync_addr);
+	*sync_addr = 0;
+	xe_vm_unbind_async(fd, vm, 0, 0, addr, size, &sync, 1);
+	if (*sync_addr != BIND_SYNC_VAL)
+		xe_wait_ufence(fd, (uint64_t *)sync_addr, BIND_SYNC_VAL, 0, NSEC_PER_SEC * 10);
+	free((void *)sync_addr);
+}
Signature · 1 line
2.48.1
Reviewed-by on v9 2/10
#5 lore raw

RE: [PATCH i-g-t v9 02/10] lib/xe: Add synchronous helpers for VM bind/unbind operations

Quoted 71 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 02/10] lib/xe: Add synchronous helpers for VM bind/unbind operations

From: Nishit Sharma <[email protected]>

Introduce synchronous wrappers for VM bind/unbind operations that handle user fence allocation, waiting, and cleanup internally. This simplifies test code by eliminating repetitive synchronization boilerplate.

---
 lib/xe/xe_ioctl.c | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
lib/xe/xe_ioctl.c index 221fd7c62..369c5887d renamed from lib/xe/xe_ioctl.c +0 -0

100644

lib/xe/xe_ioctl.c +16 -0
@@ -747,3 +747,42 @@ void xe_vm_madvise(int fd, uint32_t vm, uint64_t
 addr, uint64_t range,
 	igt_assert_eq(__xe_vm_madvise(fd, vm, addr, range, ext, type,
 op_val, policy,
 				      instance), 0);
 }
+
+#define        BIND_SYNC_VAL   0x686868
+void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
+			uint64_t addr, uint64_t size, uint32_t flags) {
+	volatile uint64_t *sync_addr = malloc(sizeof(*sync_addr));
+	struct drm_xe_sync sync = {
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.addr = to_user_pointer((uint64_t *)sync_addr),
+		.timeline_value = BIND_SYNC_VAL,
+	};
+
+	igt_assert(!!sync_addr);
+	xe_vm_bind_async_flags(fd, vm, 0, bo, 0, addr, size, &sync, 1, flags);
+	if (*sync_addr != BIND_SYNC_VAL)
+		xe_wait_ufence(fd, (uint64_t *)sync_addr, BIND_SYNC_VAL,

0, NSEC_PER_SEC * 10);

lib/xe/xe_ioctl.c +20 -0
+	/* Only free if the wait succeeds */
+	free((void *)sync_addr);
+}
+
+void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
+			  uint64_t addr, uint64_t size)
+{
+	volatile uint64_t *sync_addr = malloc(sizeof(*sync_addr));
+	struct drm_xe_sync sync = {
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.addr = to_user_pointer((uint64_t *)sync_addr),
+		.timeline_value = BIND_SYNC_VAL,
+	};
+
+	igt_assert(!!sync_addr);
+	*sync_addr = 0;
+	xe_vm_unbind_async(fd, vm, 0, 0, addr, size, &sync, 1);
+	if (*sync_addr != BIND_SYNC_VAL)
+		xe_wait_ufence(fd, (uint64_t *)sync_addr, BIND_SYNC_VAL,

0, NSEC_PER_SEC * 10);

lib/xe/xe_ioctl.c void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,

Quoted 3 lines
lib/xe/xe_ioctl.c +2 -1
+	free((void *)sync_addr);
+}
--
Quoted 1 line

2.48.1

#6 lore raw

PATCH v9 3/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test allocates a buffer in SVM, writes data to it from src GPU, and reads/verifies the data from dst GPU. Optionally, the CPU also reads or modifies the buffer and both GPUs verify the results, ensuring correct cross-GPU and CPU memory access in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 392 ++++++++++++++++++++++++++++++++++
 tests/meson.build             |   1 +
 2 files changed, 393 insertions(+)
 create mode 100644 tests/intel/xe_multi_gpusvm.c
tests/intel/xe_multi_gpusvm.c new file +392 -0
new file mode 100644
index 000000000..a80193b9a
@@ -0,0 +1,392 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+
+#include <unistd.h>
+
+#include "drmtest.h"
+#include "igt.h"
+#include "igt_multigpu.h"
+
+#include "intel_blt.h"
+#include "intel_mocs.h"
+#include "intel_reg.h"
+
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+#include "xe/xe_util.h"
+
+/**
+ * TEST: Basic multi-gpu SVM testing
+ * Category: SVM
+ * Mega feature: Compute
+ * Sub-category: Compute tests
+ * Functionality: SVM p2p access, madvise and prefetch.
+ * Test category: functionality test
+ *
+ * SUBTEST: mgpu-xgpu-access-basic
+ * Description:
+ *	Test basic cross-GPU memory access in multi-GPU SVM configuration
+ *
+ * SUBTEST: mgpu-xgpu-access-prefetch
+ * Description:
+ *	Test cross-GPU memory access with prefetch in multi-GPU SVM configuration
+ *
+ */
+
+#define MAX_XE_REGIONS	8
+#define MAX_XE_GPUS 8
+#define NUM_LOOPS 1
+#define BATCH_SIZE(_fd) ALIGN(SZ_8K, xe_get_default_alignment(_fd))
+#define BIND_SYNC_VAL 0x686868
+#define EXEC_SYNC_VAL 0x676767
+#define COPY_SIZE SZ_64M
+
+#define MULTIGPU_PREFETCH		BIT(1)
+#define MULTIGPU_XGPU_ACCESS		BIT(2)
+
+struct xe_svm_gpu_info {
+	bool supports_faults;
+	int vram_regions[MAX_XE_REGIONS];
+	unsigned int num_regions;
+	unsigned int va_bits;
+	int fd;
+};
+
+typedef void (*gpu_pair_fn)(struct xe_svm_gpu_info *src,
+			    struct xe_svm_gpu_info *dst,
+			    struct drm_xe_engine_class_instance *eci,
+			    unsigned int flags);
+
+static void for_each_gpu_pair(int num_gpus,
+			      struct xe_svm_gpu_info *gpus,
+			      struct drm_xe_engine_class_instance *eci,
+			      gpu_pair_fn fn,
+			      unsigned int flags);
+
+static void gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
+				   struct xe_svm_gpu_info *dst,
+				   struct drm_xe_engine_class_instance *eci,
+				   unsigned int flags);
+
+static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
+
+static void
+create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
+		    uint32_t *vm, uint32_t *exec_queue)
+{
+	*vm = xe_vm_create(gpu->fd,
+			   DRM_XE_VM_CREATE_FLAG_LR_MODE | DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	*exec_queue = xe_exec_queue_create(gpu->fd, *vm, eci, 0);
+	xe_vm_bind_lr_sync(gpu->fd, *vm, 0, 0, 0, 1ull << gpu->va_bits,
+			   DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR);
+}
+
+static void
+setup_sync(struct drm_xe_sync *sync, uint64_t **sync_addr, uint64_t timeline_value)
+{
+	*sync_addr = malloc(sizeof(**sync_addr));
+	igt_assert(*sync_addr);
+	sync->flags = DRM_XE_SYNC_FLAG_SIGNAL;
+	sync->type = DRM_XE_SYNC_TYPE_USER_FENCE;
+	sync->addr = to_user_pointer((uint64_t *)*sync_addr);
+	sync->timeline_value = timeline_value;
+	**sync_addr = 0;
+}
+
+static void
+cleanup_vm_and_queue(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue)
+{
+	xe_vm_unbind_lr_sync(gpu->fd, vm, 0, 0, 1ull << gpu->va_bits);
+	xe_exec_queue_destroy(gpu->fd, exec_queue);
+	xe_vm_destroy(gpu->fd, vm);
+}
+
+static void xe_multigpu_madvise(int src_fd, uint32_t vm, uint64_t addr, uint64_t size,
+				uint64_t ext, uint32_t type, int dst_fd, uint16_t policy,
+				uint32_t instance, uint32_t exec_queue)
+{
+	int ret;
+
+	if (src_fd != dst_fd) {
+		ret = __xe_vm_madvise(src_fd, vm, addr, size, ext, type, dst_fd, policy, instance);
+		if (ret == -ENOLINK) {
+			igt_info("No fast interconnect between GPU0 and GPU1, falling back to local VRAM\n");
+			ret = __xe_vm_madvise(src_fd, vm, addr, size, ext, type,
+					      DRM_XE_PREFERRED_LOC_DEFAULT_DEVICE,
+					      policy, 0);
+			if (ret) {
+				igt_info("Local VRAM madvise failed, falling back to system memory\n");
+				xe_vm_madvise(src_fd, vm, addr, size, ext, type,
+					      DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM, policy,
+					      0);
+			}
+		} else {
+			igt_assert_eq(ret, 0);
+		}
+	} else {
+		xe_vm_madvise(src_fd, vm, addr, size, ext, type, dst_fd, policy, instance);
+	}
+}
+
+static void xe_multigpu_prefetch(int src_fd, uint32_t vm, uint64_t addr, uint64_t size,
+				 struct drm_xe_sync *sync, uint64_t *sync_addr,
+				 uint32_t exec_queue, unsigned int flags)
+{
+	if (flags & MULTIGPU_PREFETCH) {
+		xe_vm_prefetch_async(src_fd, vm, 0, 0, addr, size, sync, 1,
+				     DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC);
+		if (*sync_addr != sync->timeline_value)
+			xe_wait_ufence(src_fd, (uint64_t *)sync_addr, sync->timeline_value,
+				       exec_queue, NSEC_PER_SEC * 10);
+	}
+}
+
+static void for_each_gpu_pair(int num_gpus, struct xe_svm_gpu_info *gpus,
+			      struct drm_xe_engine_class_instance *eci,
+			      gpu_pair_fn fn, unsigned int flags)
+{
+	for (int src = 0; src < num_gpus; src++) {
+		if (!gpus[src].supports_faults)
+			continue;
+
+		for (int dst = 0; dst < num_gpus; dst++) {
+			if (src == dst)
+				continue;
+			fn(&gpus[src], &gpus[dst], eci, flags);
+		}
+	}
+}
+
+static void batch_init(int fd, uint32_t vm, uint64_t src_addr,
+		       uint64_t dst_addr, uint64_t copy_size,
+		       uint32_t *bo, uint64_t *addr)
+{
+	uint32_t width = copy_size / 256;
+	uint32_t height = 1;
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	uint32_t mocs_index = intel_get_uc_mocs_index(fd);
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size, vram_if_possible(fd, 0), 0);
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *)batch;
+	cmd[i++] = MEM_COPY_CMD | (1 << 19);
+	cmd[i++] = width - 1;
+	cmd[i++] = height - 1;
+	cmd[i++] = width - 1;
+	cmd[i++] = width - 1;
+	cmd[i++] = src_addr & ((1UL << 32) - 1);
+	cmd[i++] = src_addr >> 32;
+	cmd[i++] = dst_addr & ((1UL << 32) - 1);
+	cmd[i++] = dst_addr >> 32;
+	cmd[i++] = mocs_index << XE2_MEM_COPY_MOCS_SHIFT | mocs_index;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+	/* Punch a gap in the SVM map where we map the batch_bo */
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr, batch_bo_size, 0);
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
+static void batch_fini(int fd, uint32_t vm, uint32_t bo, uint64_t addr)
+{
+	/* Unmap the batch bo by re-instating the SVM binding. */
+	xe_vm_bind_lr_sync(fd, vm, 0, 0, addr, BATCH_SIZE(fd),
+			   DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR);
+	gem_close(fd, bo);
+}
+
+static void open_pagemaps(int fd, struct xe_svm_gpu_info *info)
+{
+	unsigned int count = 0;
+	uint64_t regions = all_memory_regions(fd);
+	uint32_t region;
+
+	xe_for_each_mem_region(fd, regions, region) {
+		if (XE_IS_VRAM_MEMORY_REGION(fd, region)) {
+			struct drm_xe_mem_region *mem_region =
+				xe_mem_region(fd, 1ull << (region - 1));
+			igt_assert(count < MAX_XE_REGIONS);
+			info->vram_regions[count++] = mem_region->instance;
+		}
+	}
+
+	info->num_regions = count;
+}
+
+static int get_device_info(struct xe_svm_gpu_info gpus[], int num_gpus)
+{
+	int cnt;
+	int xe;
+	int i;
+
+	for (i = 0, cnt = 0 && i < 128; cnt < num_gpus; i++) {
+		xe = __drm_open_driver_another(i, DRIVER_XE);
+		if (xe < 0)
+			break;
+
+		gpus[cnt].fd = xe;
+		cnt++;
+	}
+
+	return cnt;
+}
+
+static int
+mgpu_check_fault_support(struct xe_svm_gpu_info *gpu1,
+			 struct xe_svm_gpu_info *gpu2)
+{
+	int ret = 0;
+
+	if (!gpu1->supports_faults || !gpu2->supports_faults) {
+		igt_debug("GPU does not support page faults, skipping execution\n");
+		ret = 1;
+	}
+	return ret;
+}
+
+static void
+copy_src_dst(struct xe_svm_gpu_info *gpu1,
+	     struct xe_svm_gpu_info *gpu2,
+	     struct drm_xe_engine_class_instance *eci,
+	     unsigned int flags)
+{
+	uint32_t vm[1];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo;
+	void *copy_src, *copy_dst;
+	uint64_t batch_addr;
+	struct drm_xe_sync sync = {};
+	uint64_t *sync_addr;
+
+	/* Checking if GPU support page faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+
+	/* Allocate source and destination buffers */
+	copy_src = aligned_alloc(xe_get_default_alignment(gpu1->fd), SZ_64M);
+	igt_assert(copy_src);
+	copy_dst = aligned_alloc(xe_get_default_alignment(gpu2->fd), SZ_64M);
+	igt_assert(copy_dst);
+
+	batch_init(gpu1->fd, vm[0], to_user_pointer(copy_src), to_user_pointer(copy_dst),
+		   COPY_SIZE, &batch_bo, &batch_addr);
+
+	/* Fill the source with a pattern, clear the destination. */
+	memset(copy_src, 0x67, COPY_SIZE);
+	memset(copy_dst, 0x0, COPY_SIZE);
+
+	xe_multigpu_madvise(gpu1->fd, vm[0], to_user_pointer(copy_dst), COPY_SIZE,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0], exec_queue[0]);
+
+	setup_sync(&sync, &sync_addr, BIND_SYNC_VAL);
+	xe_multigpu_prefetch(gpu1->fd, vm[0], to_user_pointer(copy_dst), COPY_SIZE, &sync,
+			     sync_addr, exec_queue[0], flags);
+	free(sync_addr);
+
+	sync_addr = (void *)((char *)batch_addr + SZ_4K);
+	sync.addr = to_user_pointer((uint64_t *)sync_addr);
+	sync.timeline_value = EXEC_SYNC_VAL;
+	WRITE_ONCE(*sync_addr, 0);
+
+	/* Execute a GPU copy. */
+	xe_exec_sync(gpu1->fd, exec_queue[0], batch_addr, &sync, 1);
+	if (READ_ONCE(*sync_addr) != EXEC_SYNC_VAL)
+		xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr, EXEC_SYNC_VAL, exec_queue[0],
+			       NSEC_PER_SEC * 10);
+
+	igt_assert(memcmp(copy_src, copy_dst, COPY_SIZE) == 0);
+
+	free(copy_dst);
+	free(copy_src);
+	munmap((void *)batch_addr, BATCH_SIZE(gpu1->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo, batch_addr);
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+}
+
+static void
+gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
+		       struct xe_svm_gpu_info *dst,
+		       struct drm_xe_engine_class_instance *eci,
+		       unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	copy_src_dst(src, dst, eci, flags);
+}
+
+static void
+test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
+	       struct drm_xe_engine_class_instance *eci,
+	       unsigned int flags)
+{
+	if (flags & MULTIGPU_XGPU_ACCESS)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_mem_access_wrapper, flags);
+}
+
+struct section {
+	const char *name;
+	unsigned int flags;
+};
+
+igt_main
+{
+	struct xe_svm_gpu_info gpus[MAX_XE_GPUS];
+	struct xe_device *xe;
+	int gpu, gpu_cnt;
+
+	struct drm_xe_engine_class_instance eci = {
+		.engine_class = DRM_XE_ENGINE_CLASS_COPY,
+	};
+
+	const struct section msections[] = {
+		{ "xgpu-access-basic", MULTIGPU_XGPU_ACCESS },
+		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_XGPU_ACCESS },
+		{ NULL },
+	};
+
+	igt_fixture {
+		gpu_cnt = get_device_info(gpus, ARRAY_SIZE(gpus));
+		igt_skip_on(gpu_cnt < 2);
+
+		for (gpu = 0; gpu < gpu_cnt; ++gpu) {
+			igt_assert(gpu < MAX_XE_GPUS);
+
+			open_pagemaps(gpus[gpu].fd, &gpus[gpu]);
+			/* NOTE! inverted return value. */
+			gpus[gpu].supports_faults = !xe_supports_faults(gpus[gpu].fd);
+			fprintf(stderr, "GPU %u has %u VRAM regions%s, and %s SVM VMs.\n",
+				gpu, gpus[gpu].num_regions,
+				gpus[gpu].num_regions != 1 ? "s" : "",
+				gpus[gpu].supports_faults ? "supports" : "doesn't support");
+
+			xe = xe_device_get(gpus[gpu].fd);
+			gpus[gpu].va_bits = xe->va_bits;
+		}
+	}
+
+	igt_describe("gpu-gpu write-read");
+	for (const struct section *s = msections; s->name; s++) {
+		igt_subtest_f("mgpu-%s", s->name)
+			test_mgpu_exec(gpu_cnt, gpus, &eci, s->flags);
+	}
+
+	igt_fixture {
+		int cnt;
+
+		for (cnt = 0; cnt < gpu_cnt; cnt++)
+			drm_close_driver(gpus[cnt].fd);
+	}
+}
tests/meson.build +1 -0
index 9736f2338..1209f84a4 100644
@@ -313,6 +313,7 @@ intel_xe_progs = [
 	'xe_media_fill',
 	'xe_mmap',
 	'xe_module_load',
+        'xe_multi_gpusvm',
 	'xe_noexec_ping_pong',
 	'xe_oa',
 	'xe_pat',
Signature · 1 line
2.48.1
Reviewed-by on v9 3/10
#7 lore raw

RE: [PATCH i-g-t v9 03/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test

Quoted 458 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 03/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test

From: Nishit Sharma <[email protected]>

This test allocates a buffer in SVM, writes data to it from src GPU, and reads/verifies the data from dst GPU. Optionally, the CPU also reads or modifies the buffer and both GPUs verify the results, ensuring correct cross- GPU and CPU memory access in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 392
++++++++++++++++++++++++++++++++++
 tests/meson.build             |   1 +
 2 files changed, 393 insertions(+)
 create mode 100644 tests/intel/xe_multi_gpusvm.c
tests/intel/xe_multi_gpusvm.c new file +34 -0
new file mode 100644 index 000000000..a80193b9a
@@ -0,0 +1,392 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+
+#include <unistd.h>
+
+#include "drmtest.h"
+#include "igt.h"
+#include "igt_multigpu.h"
+
+#include "intel_blt.h"
+#include "intel_mocs.h"
+#include "intel_reg.h"
+
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+#include "xe/xe_util.h"
+
+/**
+ * TEST: Basic multi-gpu SVM testing
+ * Category: SVM
+ * Mega feature: Compute
+ * Sub-category: Compute tests
+ * Functionality: SVM p2p access, madvise and prefetch.
+ * Test category: functionality test
+ *
+ * SUBTEST: mgpu-xgpu-access-basic
+ * Description:
+ *	Test basic cross-GPU memory access in multi-GPU SVM configuration
+ *
+ * SUBTEST: mgpu-xgpu-access-prefetch
+ * Description:
+ *	Test cross-GPU memory access with prefetch in multi-GPU SVM

configuration
+ *
+ */

tests/intel/xe_multi_gpusvm.c new file +6 -0
+
+#define MAX_XE_REGIONS	8
+#define MAX_XE_GPUS 8
+#define NUM_LOOPS 1
+#define BATCH_SIZE(_fd) ALIGN(SZ_8K, xe_get_default_alignment(_fd))
+#define BIND_SYNC_VAL 0x686868 #define EXEC_SYNC_VAL 0x676767

#define

tests/intel/xe_multi_gpusvm.c new file +33 -0
+COPY_SIZE SZ_64M
+
+#define MULTIGPU_PREFETCH		BIT(1)
+#define MULTIGPU_XGPU_ACCESS		BIT(2)
+
+struct xe_svm_gpu_info {
+	bool supports_faults;
+	int vram_regions[MAX_XE_REGIONS];
+	unsigned int num_regions;
+	unsigned int va_bits;
+	int fd;
+};
+
+typedef void (*gpu_pair_fn)(struct xe_svm_gpu_info *src,
+			    struct xe_svm_gpu_info *dst,
+			    struct drm_xe_engine_class_instance *eci,
+			    unsigned int flags);
+
+static void for_each_gpu_pair(int num_gpus,
+			      struct xe_svm_gpu_info *gpus,
+			      struct drm_xe_engine_class_instance *eci,
+			      gpu_pair_fn fn,
+			      unsigned int flags);
+
+static void gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
+				   struct xe_svm_gpu_info *dst,
+				   struct drm_xe_engine_class_instance *eci,
+				   unsigned int flags);
+
+static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
+
+static void
+create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct

drm_xe_engine_class_instance *eci,

tests/intel/xe_multi_gpusvm.c new file +3 -0
+		    uint32_t *vm, uint32_t *exec_queue) {
+	*vm = xe_vm_create(gpu->fd,
+			   DRM_XE_VM_CREATE_FLAG_LR_MODE |

DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);

tests/intel/xe_multi_gpusvm.c new file +19 -0
+	*exec_queue = xe_exec_queue_create(gpu->fd, *vm, eci, 0);
+	xe_vm_bind_lr_sync(gpu->fd, *vm, 0, 0, 0, 1ull << gpu->va_bits,
+			   DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR);
+}
+
+static void
+setup_sync(struct drm_xe_sync *sync, uint64_t **sync_addr, uint64_t
+timeline_value) {
+	*sync_addr = malloc(sizeof(**sync_addr));
+	igt_assert(*sync_addr);
+	sync->flags = DRM_XE_SYNC_FLAG_SIGNAL;
+	sync->type = DRM_XE_SYNC_TYPE_USER_FENCE;
+	sync->addr = to_user_pointer((uint64_t *)*sync_addr);
+	sync->timeline_value = timeline_value;
+	**sync_addr = 0;
+}
+
+static void
+cleanup_vm_and_queue(struct xe_svm_gpu_info *gpu, uint32_t vm,

uint32_t

tests/intel/xe_multi_gpusvm.c new file +7 -0
+exec_queue) {
+	xe_vm_unbind_lr_sync(gpu->fd, vm, 0, 0, 1ull << gpu->va_bits);
+	xe_exec_queue_destroy(gpu->fd, exec_queue);
+	xe_vm_destroy(gpu->fd, vm);
+}
+
+static void xe_multigpu_madvise(int src_fd, uint32_t vm, uint64_t addr,

uint64_t size,

tests/intel/xe_multi_gpusvm.c new file +1 -0
+				uint64_t ext, uint32_t type, int dst_fd,

uint16_t policy,

tests/intel/xe_multi_gpusvm.c new file +5 -0
+				uint32_t instance, uint32_t exec_queue) {
+	int ret;
+
+	if (src_fd != dst_fd) {
+		ret = __xe_vm_madvise(src_fd, vm, addr, size, ext, type,

dst_fd, policy, instance);

tests/intel/xe_multi_gpusvm.c new file +2 -0
+		if (ret == -ENOLINK) {
+			igt_info("No fast interconnect between GPU0 and

GPU1, falling back to local VRAM\n");

tests/intel/xe_multi_gpusvm.c new file +1 -0
+			ret = __xe_vm_madvise(src_fd, vm, addr, size, ext,

type,
+
DRM_XE_PREFERRED_LOC_DEFAULT_DEVICE,

tests/intel/xe_multi_gpusvm.c new file +3 -0
+					      policy, 0);
+			if (ret) {
+				igt_info("Local VRAM madvise failed, falling

back to system memory\n");

tests/intel/xe_multi_gpusvm.c new file +1 -0
+				xe_vm_madvise(src_fd, vm, addr, size, ext,

type,
+
DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM, policy,

tests/intel/xe_multi_gpusvm.c new file +7 -0
+					      0);
+			}
+		} else {
+			igt_assert_eq(ret, 0);
+		}
+	} else {
+		xe_vm_madvise(src_fd, vm, addr, size, ext, type, dst_fd,

policy, instance);

tests/intel/xe_multi_gpusvm.c new file +4 -0
+	}
+}
+
+static void xe_multigpu_prefetch(int src_fd, uint32_t vm, uint64_t addr,

uint64_t size,

tests/intel/xe_multi_gpusvm.c new file +1 -0
+				 struct drm_xe_sync *sync, uint64_t

*sync_addr,

tests/intel/xe_multi_gpusvm.c new file +4 -0
+				 uint32_t exec_queue, unsigned int flags) {
+	if (flags & MULTIGPU_PREFETCH) {
+		xe_vm_prefetch_async(src_fd, vm, 0, 0, addr, size, sync, 1,
+

DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC);

tests/intel/xe_multi_gpusvm.c new file +2 -0
+		if (*sync_addr != sync->timeline_value)
+			xe_wait_ufence(src_fd, (uint64_t *)sync_addr, sync-
Quoted 1 line

timeline_value,

tests/intel/xe_multi_gpusvm.c new file +5 -0
+				       exec_queue, NSEC_PER_SEC * 10);
+	}
+}
+
+static void for_each_gpu_pair(int num_gpus, struct xe_svm_gpu_info

*gpus,

tests/intel/xe_multi_gpusvm.c new file +29 -0
+			      struct drm_xe_engine_class_instance *eci,
+			      gpu_pair_fn fn, unsigned int flags) {
+	for (int src = 0; src < num_gpus; src++) {
+		if (!gpus[src].supports_faults)
+			continue;
+
+		for (int dst = 0; dst < num_gpus; dst++) {
+			if (src == dst)
+				continue;
+			fn(&gpus[src], &gpus[dst], eci, flags);
+		}
+	}
+}
+
+static void batch_init(int fd, uint32_t vm, uint64_t src_addr,
+		       uint64_t dst_addr, uint64_t copy_size,
+		       uint32_t *bo, uint64_t *addr)
+{
+	uint32_t width = copy_size / 256;
+	uint32_t height = 1;
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	uint32_t mocs_index = intel_get_uc_mocs_index(fd);
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size,

vram_if_possible(fd, 0), 0);

tests/intel/xe_multi_gpusvm.c new file +12 -0
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *)batch;
+	cmd[i++] = MEM_COPY_CMD | (1 << 19);
+	cmd[i++] = width - 1;
+	cmd[i++] = height - 1;
+	cmd[i++] = width - 1;
+	cmd[i++] = width - 1;
+	cmd[i++] = src_addr & ((1UL << 32) - 1);
+	cmd[i++] = src_addr >> 32;
+	cmd[i++] = dst_addr & ((1UL << 32) - 1);
+	cmd[i++] = dst_addr >> 32;
+	cmd[i++] = mocs_index << XE2_MEM_COPY_MOCS_SHIFT |

mocs_index;

tests/intel/xe_multi_gpusvm.c new file +6 -0
+	cmd[i++] = MI_BATCH_BUFFER_END;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+	/* Punch a gap in the SVM map where we map the batch_bo */
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr,

batch_bo_size, 0);

tests/intel/xe_multi_gpusvm.c new file +23 -0
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
+static void batch_fini(int fd, uint32_t vm, uint32_t bo, uint64_t addr)
+{
+	/* Unmap the batch bo by re-instating the SVM binding. */
+	xe_vm_bind_lr_sync(fd, vm, 0, 0, addr, BATCH_SIZE(fd),
+			   DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR);
+	gem_close(fd, bo);
+}
+
+static void open_pagemaps(int fd, struct xe_svm_gpu_info *info) {
+	unsigned int count = 0;
+	uint64_t regions = all_memory_regions(fd);
+	uint32_t region;
+
+	xe_for_each_mem_region(fd, regions, region) {
+		if (XE_IS_VRAM_MEMORY_REGION(fd, region)) {
+			struct drm_xe_mem_region *mem_region =
+				xe_mem_region(fd, 1ull << (region - 1));
+			igt_assert(count < MAX_XE_REGIONS);
+			info->vram_regions[count++] = mem_region-
Quoted 1 line

instance;

tests/intel/xe_multi_gpusvm.c new file +32 -0
+		}
+	}
+
+	info->num_regions = count;
+}
+
+static int get_device_info(struct xe_svm_gpu_info gpus[], int num_gpus)
+{
+	int cnt;
+	int xe;
+	int i;
+
+	for (i = 0, cnt = 0 && i < 128; cnt < num_gpus; i++) {
+		xe = __drm_open_driver_another(i, DRIVER_XE);
+		if (xe < 0)
+			break;
+
+		gpus[cnt].fd = xe;
+		cnt++;
+	}
+
+	return cnt;
+}
+
+static int
+mgpu_check_fault_support(struct xe_svm_gpu_info *gpu1,
+			 struct xe_svm_gpu_info *gpu2)
+{
+	int ret = 0;
+
+	if (!gpu1->supports_faults || !gpu2->supports_faults) {
+		igt_debug("GPU does not support page faults, skipping

execution\n");

tests/intel/xe_multi_gpusvm.c new file +27 -0
+		ret = 1;
+	}
+	return ret;
+}
+
+static void
+copy_src_dst(struct xe_svm_gpu_info *gpu1,
+	     struct xe_svm_gpu_info *gpu2,
+	     struct drm_xe_engine_class_instance *eci,
+	     unsigned int flags)
+{
+	uint32_t vm[1];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo;
+	void *copy_src, *copy_dst;
+	uint64_t batch_addr;
+	struct drm_xe_sync sync = {};
+	uint64_t *sync_addr;
+
+	/* Checking if GPU support page faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+
+	/* Allocate source and destination buffers */
+	copy_src = aligned_alloc(xe_get_default_alignment(gpu1->fd),

SZ_64M);

tests/intel/xe_multi_gpusvm.c new file +2 -0
+	igt_assert(copy_src);
+	copy_dst = aligned_alloc(xe_get_default_alignment(gpu2->fd),

SZ_64M);

tests/intel/xe_multi_gpusvm.c new file +3 -0
+	igt_assert(copy_dst);
+
+	batch_init(gpu1->fd, vm[0], to_user_pointer(copy_src),

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c new file +7 -0
+		   COPY_SIZE, &batch_bo, &batch_addr);
+
+	/* Fill the source with a pattern, clear the destination. */
+	memset(copy_src, 0x67, COPY_SIZE);
+	memset(copy_dst, 0x0, COPY_SIZE);
+
+	xe_multigpu_madvise(gpu1->fd, vm[0], to_user_pointer(copy_dst),

COPY_SIZE,

tests/intel/xe_multi_gpusvm.c new file +2 -0
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0],

exec_queue[0]);

tests/intel/xe_multi_gpusvm.c new file +3 -0
+
+	setup_sync(&sync, &sync_addr, BIND_SYNC_VAL);
+	xe_multigpu_prefetch(gpu1->fd, vm[0], to_user_pointer(copy_dst),

COPY_SIZE, &sync,

tests/intel/xe_multi_gpusvm.c new file +12 -0
+			     sync_addr, exec_queue[0], flags);
+	free(sync_addr);
+
+	sync_addr = (void *)((char *)batch_addr + SZ_4K);
+	sync.addr = to_user_pointer((uint64_t *)sync_addr);
+	sync.timeline_value = EXEC_SYNC_VAL;
+	WRITE_ONCE(*sync_addr, 0);
+
+	/* Execute a GPU copy. */
+	xe_exec_sync(gpu1->fd, exec_queue[0], batch_addr, &sync, 1);
+	if (READ_ONCE(*sync_addr) != EXEC_SYNC_VAL)
+		xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr,

EXEC_SYNC_VAL, exec_queue[0],

tests/intel/xe_multi_gpusvm.c new file +29 -0
+			       NSEC_PER_SEC * 10);
+
+	igt_assert(memcmp(copy_src, copy_dst, COPY_SIZE) == 0);
+
+	free(copy_dst);
+	free(copy_src);
+	munmap((void *)batch_addr, BATCH_SIZE(gpu1->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo, batch_addr);
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]); }
+
+static void
+gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
+		       struct xe_svm_gpu_info *dst,
+		       struct drm_xe_engine_class_instance *eci,
+		       unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	copy_src_dst(src, dst, eci, flags);
+}
+
+static void
+test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
+	       struct drm_xe_engine_class_instance *eci,
+	       unsigned int flags)
+{
+	if (flags & MULTIGPU_XGPU_ACCESS)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_mem_access_wrapper, flags);

tests/intel/xe_multi_gpusvm.c new file +20 -0
+}
+
+struct section {
+	const char *name;
+	unsigned int flags;
+};
+
+igt_main
+{
+	struct xe_svm_gpu_info gpus[MAX_XE_GPUS];
+	struct xe_device *xe;
+	int gpu, gpu_cnt;
+
+	struct drm_xe_engine_class_instance eci = {
+		.engine_class = DRM_XE_ENGINE_CLASS_COPY,
+	};
+
+	const struct section msections[] = {
+		{ "xgpu-access-basic", MULTIGPU_XGPU_ACCESS },
+		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH |

MULTIGPU_XGPU_ACCESS },

tests/intel/xe_multi_gpusvm.c new file +13 -0
+		{ NULL },
+	};
+
+	igt_fixture {
+		gpu_cnt = get_device_info(gpus, ARRAY_SIZE(gpus));
+		igt_skip_on(gpu_cnt < 2);
+
+		for (gpu = 0; gpu < gpu_cnt; ++gpu) {
+			igt_assert(gpu < MAX_XE_GPUS);
+
+			open_pagemaps(gpus[gpu].fd, &gpus[gpu]);
+			/* NOTE! inverted return value. */
+			gpus[gpu].supports_faults =

!xe_supports_faults(gpus[gpu].fd);

tests/intel/xe_multi_gpusvm.c new file +1 -0
+			fprintf(stderr, "GPU %u has %u VRAM regions%s,

and %s SVM VMs.\n",

tests/intel/xe_multi_gpusvm.c new file +3 -0
+				gpu, gpus[gpu].num_regions,
+				gpus[gpu].num_regions != 1 ? "s" : "",
+				gpus[gpu].supports_faults ? "supports" :

"doesn't support");

tests/intel/xe_multi_gpusvm.c new file +19 -0
+
+			xe = xe_device_get(gpus[gpu].fd);
+			gpus[gpu].va_bits = xe->va_bits;
+		}
+	}
+
+	igt_describe("gpu-gpu write-read");
+	for (const struct section *s = msections; s->name; s++) {
+		igt_subtest_f("mgpu-%s", s->name)
+			test_mgpu_exec(gpu_cnt, gpus, &eci, s->flags);
+	}
+
+	igt_fixture {
+		int cnt;
+
+		for (cnt = 0; cnt < gpu_cnt; cnt++)
+			drm_close_driver(gpus[cnt].fd);
+	}
+}
tests/meson.build index renamed from tests/meson.build +0 -0

9736f2338..1209f84a4 100644

tests/meson.build intel_xe_progs = [

Quoted 8 lines
tests/meson.build +1 -1
@@ -313,6 +313,7 @@ intel_xe_progs = [
 	'xe_media_fill',
 	'xe_mmap',
 	'xe_module_load',
+        'xe_multi_gpusvm',
 	'xe_noexec_ping_pong',
 	'xe_oa',
 	'xe_pat',
--
Quoted 1 line

2.48.1

#8 lore raw

Re: [PATCH i-g-t v9 03/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test

In reply to [email protected]

Hi nishit.sharma,

Quoted 7 lines · On 2025-12-01 at 09:03:42 +0000, [email protected] wrote:

From: Nishit Sharma <[email protected]>

This test allocates a buffer in SVM, writes data to it from src GPU, and reads/verifies the data from dst GPU. Optionally, the CPU also reads or modifies the buffer and both GPUs verify the results, ensuring correct cross-GPU and CPU memory access in a multi-GPU environment.

+cc Thomas Hellström <[email protected]>

Quoted 3 lines
---
 tests/intel/xe_multi_gpusvm.c | 392 ++++++++++++++++++++++++++++++++++

This is a bad name for a test, once again - either xe_gpusvm.c or xe_svm.c or xe_multigpu_svm.c

Imho best one is xe_svm.c

The 'multi' word is has no relevance here, it should be 'multigpu' or not used.

tests/intel/xe_multi_gpusvm.c line 3

Quoted 13 lines
 tests/meson.build             |   1 +
 2 files changed, 393 insertions(+)
 create mode 100644 tests/intel/xe_multi_gpusvm.c
tests/intel/xe_multi_gpusvm.c new file +3 -0
new file mode 100644
index 000000000..a80193b9a
@@ -0,0 +1,392 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation

This should be 2025. This cannot be merged until corrected.

Quoted 9 lines
tests/intel/xe_multi_gpusvm.c new file +9 -0
+ */
+
+#include <unistd.h>
+
+#include "drmtest.h"
+#include "igt.h"
+#include "igt_multigpu.h"
+
+#include "intel_blt.h"

tests/intel/xe_multi_gpusvm.c line 22

Quoted 10 lines
tests/intel/xe_multi_gpusvm.c new file +10 -0
+#include "intel_mocs.h"
+#include "intel_reg.h"
+
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+#include "xe/xe_util.h"
+
+/**
+ * TEST: Basic multi-gpu SVM testing
+ * Category: SVM

You need a Desciption: here, it is global test description like IGT_TEST_DESCRIPTION() used in old descriptions. Also decipher SVM shortcut in it.

For example look into tests/kms_debugfs.c:

/**
* TEST: kms debugfs test
* Description: Read entries from debugfs with all displays on and with
* all displays off.

Regards,
Kamil

Quoted 14 lines
tests/intel/xe_multi_gpusvm.c new file +14 -0
+ * Mega feature: Compute
+ * Sub-category: Compute tests
+ * Functionality: SVM p2p access, madvise and prefetch.
+ * Test category: functionality test
+ *
+ * SUBTEST: mgpu-xgpu-access-basic
+ * Description:
+ *	Test basic cross-GPU memory access in multi-GPU SVM configuration
+ *
+ * SUBTEST: mgpu-xgpu-access-prefetch
+ * Description:
+ *	Test cross-GPU memory access with prefetch in multi-GPU SVM configuration
+ *
+ */

[cut]

#9 lore raw

RE: [PATCH i-g-t v9 03/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test

Hi kamil,

Will update the test name and resend the series.

Regards
Nishit

-----Original Message-----
From: Kamil Konieczny <[email protected]>
Sent: Monday, December 1, 2025 9:34 PM
To: Sharma, Nishit <[email protected]>
Cc: [email protected]; Gurram, Pravalika <[email protected]>; Thomas Hellström <[email protected]>
Subject: Re: [PATCH i-g-t v9 03/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU xGPU memory access test

Hi nishit.sharma,

Quoted 7 lines · On 2025-12-01 at 09:03:42 +0000, [email protected] wrote:

From: Nishit Sharma <[email protected]>

This test allocates a buffer in SVM, writes data to it from src GPU, and reads/verifies the data from dst GPU. Optionally, the CPU also reads or modifies the buffer and both GPUs verify the results, ensuring correct cross-GPU and CPU memory access in a multi-GPU environment.

+cc Thomas Hellström <[email protected]>

Quoted 4 lines
---
 tests/intel/xe_multi_gpusvm.c | 392 

++++++++++++++++++++++++++++++++++

This is a bad name for a test, once again - either xe_gpusvm.c or xe_svm.c or xe_multigpu_svm.c

Imho best one is xe_svm.c

The 'multi' word is has no relevance here, it should be 'multigpu' or not used.

tests/intel/xe_multi_gpusvm.c line 3

Quoted 13 lines
 tests/meson.build             |   1 +
 2 files changed, 393 insertions(+)
 create mode 100644 tests/intel/xe_multi_gpusvm.c
(quoted diff) +0 -0

b/tests/intel/xe_multi_gpusvm.c new file mode 100644 index 000000000..a80193b9a

tests/intel/xe_multi_gpusvm.c new file +3 -0
@@ -0,0 +1,392 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation

This should be 2025. This cannot be merged until corrected.

Quoted 9 lines
tests/intel/xe_multi_gpusvm.c new file +9 -0
+ */
+
+#include <unistd.h>
+
+#include "drmtest.h"
+#include "igt.h"
+#include "igt_multigpu.h"
+
+#include "intel_blt.h"

tests/intel/xe_multi_gpusvm.c line 22

Quoted 10 lines
tests/intel/xe_multi_gpusvm.c new file +10 -0
+#include "intel_mocs.h"
+#include "intel_reg.h"
+
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+#include "xe/xe_util.h"
+
+/**
+ * TEST: Basic multi-gpu SVM testing
+ * Category: SVM

You need a Desciption: here, it is global test description like IGT_TEST_DESCRIPTION() used in old descriptions. Also decipher SVM shortcut in it.

For example look into tests/kms_debugfs.c:

/**
* TEST: kms debugfs test
* Description: Read entries from debugfs with all displays on and with
* all displays off.

Regards,
Kamil

Quoted 14 lines
tests/intel/xe_multi_gpusvm.c new file +14 -0
+ * Mega feature: Compute
+ * Sub-category: Compute tests
+ * Functionality: SVM p2p access, madvise and prefetch.
+ * Test category: functionality test
+ *
+ * SUBTEST: mgpu-xgpu-access-basic
+ * Description:
+ *	Test basic cross-GPU memory access in multi-GPU SVM configuration
+ *
+ * SUBTEST: mgpu-xgpu-access-prefetch
+ * Description:
+ *	Test cross-GPU memory access with prefetch in multi-GPU SVM configuration
+ *
+ */

[cut]

#10 lore raw

PATCH v9 4/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU atomic operations

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test performs atomic increment operation on a shared SVM buffer from both GPUs and the CPU in a multi-GPU environment. It uses madvise and prefetch to control buffer placement and verifies correctness and ordering of atomic updates across agents.

---
 tests/intel/xe_multi_gpusvm.c | 205 +++++++++++++++++++++++++++++++++-
 1 file changed, 203 insertions(+), 2 deletions(-)
tests/intel/xe_multi_gpusvm.c +203 -2
index a80193b9a..1d126c740 100644
@@ -33,6 +33,17 @@
  * Description:
  *	Test cross-GPU memory access with prefetch in multi-GPU SVM configuration
  *
+ * SUBTEST: mgpu-atomic-op-basic
+ * Description:
+ *	Test basic cross-GPU atomic increment operations in multi-GPU SVM configuration
+ *	operation on GPU1 and then atomic operation on GPU2 using same
+ *	address
+ *
+ * SUBTEST: mgpu-atomic-op-prefetch
+ * Description:
+ *	Tests cross-GPU atomic increment operations with explicit memory prefetch
+ *	to validate SVM atomic operations in multi-GPU config
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -42,9 +53,15 @@
 #define BIND_SYNC_VAL 0x686868
 #define EXEC_SYNC_VAL 0x676767
 #define COPY_SIZE SZ_64M
+#define	ATOMIC_OP_VAL	56
 
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
+#define MULTIGPU_ATOMIC_OP		BIT(3)
+
+#define INIT	2
+#define STORE	3
+#define ATOMIC	4
 
 struct xe_svm_gpu_info {
 	bool supports_faults;
@@ -59,6 +76,16 @@ typedef void (*gpu_pair_fn)(struct xe_svm_gpu_info *src,
 			    struct drm_xe_engine_class_instance *eci,
 			    unsigned int flags);
 
+struct test_exec_data {
+	uint32_t batch[32];
+	uint64_t pad;
+	uint64_t vm_sync;
+	uint64_t exec_sync;
+	uint32_t data;
+	uint32_t expected_data;
+	uint64_t batch_addr;
+};
+
 static void for_each_gpu_pair(int num_gpus,
 			      struct xe_svm_gpu_info *gpus,
 			      struct drm_xe_engine_class_instance *eci,
@@ -70,7 +97,10 @@ static void gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 				   struct drm_xe_engine_class_instance *eci,
 				   unsigned int flags);
 
-static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
+static void gpu_atomic_inc_wrapper(struct xe_svm_gpu_info *src,
+				   struct xe_svm_gpu_info *dst,
+				   struct drm_xe_engine_class_instance *eci,
+				   unsigned int flags);
 
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
@@ -159,6 +189,35 @@ static void for_each_gpu_pair(int num_gpus, struct xe_svm_gpu_info *gpus,
 	}
 }
 
+static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
+
+static void
+atomic_batch_init(int fd, uint32_t vm, uint64_t src_addr,
+		  uint32_t *bo, uint64_t *addr)
+{
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size, vram_if_possible(fd, 0), 0);
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *)batch;
+
+	cmd[i++] = MI_ATOMIC | MI_ATOMIC_INC;
+	cmd[i++] = src_addr;
+	cmd[i++] = src_addr >> 32;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+	/* Punch a gap in the SVM map where we map the batch_bo */
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr, batch_bo_size, 0);
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
 static void batch_init(int fd, uint32_t vm, uint64_t src_addr,
 		       uint64_t dst_addr, uint64_t copy_size,
 		       uint32_t *bo, uint64_t *addr)
@@ -253,6 +312,51 @@ mgpu_check_fault_support(struct xe_svm_gpu_info *gpu1,
 	return ret;
 }
 
+static void
+gpu_madvise_sync(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue,
+		 uint64_t dst_addr, uint64_t *batch_addr, unsigned int flags)
+{
+	struct drm_xe_sync sync = {};
+	uint64_t *sync_addr;
+
+	xe_multigpu_madvise(gpu->fd, vm, dst_addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu->fd, 0, gpu->vram_regions[0], exec_queue);
+
+	setup_sync(&sync, &sync_addr, BIND_SYNC_VAL);
+	xe_multigpu_prefetch(gpu->fd, vm, dst_addr, SZ_4K, &sync,
+			     sync_addr, exec_queue, flags);
+	free(sync_addr);
+
+	sync_addr = (void *)((char *)*batch_addr + SZ_4K);
+	sync.addr = to_user_pointer((uint64_t *)sync_addr);
+	sync.timeline_value = EXEC_SYNC_VAL;
+	WRITE_ONCE(*sync_addr, 0);
+
+	xe_exec_sync(gpu->fd, exec_queue, *batch_addr, &sync, 1);
+	if (READ_ONCE(*sync_addr) != EXEC_SYNC_VAL)
+		xe_wait_ufence(gpu->fd, (uint64_t *)sync_addr, EXEC_SYNC_VAL, exec_queue,
+			       NSEC_PER_SEC * 10);
+}
+
+static void
+gpu_batch_create(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue,
+		 uint64_t src_addr, uint64_t dst_addr,
+		 uint32_t *batch_bo, uint64_t *batch_addr,
+		 unsigned int flags, int op_type)
+{
+	switch (op_type) {
+	case ATOMIC:
+		atomic_batch_init(gpu->fd, vm, src_addr, batch_bo, batch_addr);
+		break;
+	case INIT:
+		batch_init(gpu->fd, vm, src_addr, dst_addr, SZ_4K, batch_bo, batch_addr);
+		break;
+	default:
+		igt_assert(!"Unknown batch op_type");
+	}
+}
+
 static void
 copy_src_dst(struct xe_svm_gpu_info *gpu1,
 	     struct xe_svm_gpu_info *gpu2,
@@ -315,6 +419,87 @@ copy_src_dst(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
 }
 
+static void
+atomic_inc_op(struct xe_svm_gpu_info *gpu1,
+	      struct xe_svm_gpu_info *gpu2,
+	      struct drm_xe_engine_class_instance *eci,
+	      unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	struct test_exec_data *data;
+	uint64_t batch_addr[2];
+	void *copy_dst;
+	uint32_t final_value;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	data[0].vm_sync = 0;
+	addr = to_user_pointer(data);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	WRITE_ONCE(*(uint64_t *)addr, ATOMIC_OP_VAL - 1);
+
+	/* GPU1: Atomic Batch create */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, ATOMIC);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr, &batch_addr[0], flags);
+
+	/* GPU2 --> copy from GPU1 */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, to_user_pointer(copy_dst),
+			 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+			 &batch_addr[1], flags);
+
+	/* NOW CPU can read copy_dst (GPU2 ATOMIC op) */
+	final_value = *(uint32_t *)copy_dst;
+	igt_assert_eq(final_value, ATOMIC_OP_VAL);
+
+	/* GPU2: Atomic Batch create */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst), 0,
+			 &batch_bo[1], &batch_addr[1], flags, ATOMIC);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+			 &batch_addr[1], flags);
+
+	/* GPU1 --> copy from GPU2 */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], to_user_pointer(copy_dst), addr,
+			 &batch_bo[0], &batch_addr[0], flags, INIT);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[1], addr, &batch_addr[0], flags);
+
+	/* NOW CPU can read addr (GPU1 ATOMIC op) */
+	final_value = *(uint32_t *)addr;
+	igt_assert_eq(final_value, ATOMIC_OP_VAL + 1);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -327,6 +512,18 @@ gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 	copy_src_dst(src, dst, eci, flags);
 }
 
+static void
+gpu_atomic_inc_wrapper(struct xe_svm_gpu_info *src,
+		       struct xe_svm_gpu_info *dst,
+		       struct drm_xe_engine_class_instance *eci,
+		       unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	atomic_inc_op(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci,
@@ -334,6 +531,8 @@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 {
 	if (flags & MULTIGPU_XGPU_ACCESS)
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_mem_access_wrapper, flags);
+	if (flags & MULTIGPU_ATOMIC_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_atomic_inc_wrapper, flags);
 }
 
 struct section {
@@ -354,6 +553,8 @@ igt_main
 	const struct section msections[] = {
 		{ "xgpu-access-basic", MULTIGPU_XGPU_ACCESS },
 		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_XGPU_ACCESS },
+		{ "atomic-op-basic", MULTIGPU_ATOMIC_OP },
+		{ "atomic-op-prefetch", MULTIGPU_PREFETCH | MULTIGPU_ATOMIC_OP },
 		{ NULL },
 	};
 
@@ -377,7 +578,7 @@ igt_main
 		}
 	}
 
-	igt_describe("gpu-gpu write-read");
+	igt_describe("multigpu svm operations");
 	for (const struct section *s = msections; s->name; s++) {
 		igt_subtest_f("mgpu-%s", s->name)
 			test_mgpu_exec(gpu_cnt, gpus, &eci, s->flags);
Signature · 1 line
2.48.1
Reviewed-by on v9 4/10
#11 lore raw

RE: [PATCH i-g-t v9 04/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU atomic operations

Quoted 330 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 04/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU atomic operations

From: Nishit Sharma <[email protected]>

This test performs atomic increment operation on a shared SVM buffer from both GPUs and the CPU in a multi-GPU environment. It uses madvise and prefetch to control buffer placement and verifies correctness and ordering of atomic updates across agents.

---
 tests/intel/xe_multi_gpusvm.c | 205
+++++++++++++++++++++++++++++++++-
 1 file changed, 203 insertions(+), 2 deletions(-)
tests/intel/xe_multi_gpusvm.c +0 -0
index a80193b9a..1d126c740 100644
@@ -33,6 +33,17 @@
  * Description:
  *	Test cross-GPU memory access with prefetch in multi-GPU SVM

configuration
*
+ * SUBTEST: mgpu-atomic-op-basic
+ * Description:
+ * Test basic cross-GPU atomic increment operations in multi-GPU SVM
configuration
+ * operation on GPU1 and then atomic operation on GPU2 using same
+ * address
+ *
+ * SUBTEST: mgpu-atomic-op-prefetch
+ * Description:
+ * Tests cross-GPU atomic increment operations with explicit memory
prefetch
+ * to validate SVM atomic operations in multi-GPU config
+ *
*/

#define MAX_XE_REGIONS 8

tests/intel/xe_multi_gpusvm.c +16 -0
@@ -42,9 +53,15 @@
 #define BIND_SYNC_VAL 0x686868
 #define EXEC_SYNC_VAL 0x676767
 #define COPY_SIZE SZ_64M
+#define	ATOMIC_OP_VAL	56
 
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
+#define MULTIGPU_ATOMIC_OP		BIT(3)
+
+#define INIT	2
+#define STORE	3
+#define ATOMIC	4
 
 struct xe_svm_gpu_info {
 	bool supports_faults;
@@ -59,6 +76,16 @@ typedef void (*gpu_pair_fn)(struct xe_svm_gpu_info
 *src,
 			    struct drm_xe_engine_class_instance *eci,
 			    unsigned int flags);
 
+struct test_exec_data {
+	uint32_t batch[32];
+	uint64_t pad;
+	uint64_t vm_sync;
+	uint64_t exec_sync;
+	uint32_t data;
+	uint32_t expected_data;
+	uint64_t batch_addr;
+};
+
 static void for_each_gpu_pair(int num_gpus,
 			      struct xe_svm_gpu_info *gpus,

struct drm_xe_engine_class_instance *eci, @@ -
70,7 +97,10 @@ static void gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,

tests/intel/xe_multi_gpusvm.c +4 -1
 				   struct drm_xe_engine_class_instance *eci,
 				   unsigned int flags);
 
-static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
+static void gpu_atomic_inc_wrapper(struct xe_svm_gpu_info *src,
+				   struct xe_svm_gpu_info *dst,
+				   struct drm_xe_engine_class_instance *eci,
+				   unsigned int flags);
 
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct

drm_xe_engine_class_instance *eci, @@ -159,6 +189,35 @@ static void for_each_gpu_pair(int num_gpus, struct xe_svm_gpu_info *gpus,

tests/intel/xe_multi_gpusvm.c +14 -0
 	}
 }
 
+static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
+
+static void
+atomic_batch_init(int fd, uint32_t vm, uint64_t src_addr,
+		  uint32_t *bo, uint64_t *addr)
+{
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size,

vram_if_possible(fd, 0), 0);

tests/intel/xe_multi_gpusvm.c +11 -0
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *)batch;
+
+	cmd[i++] = MI_ATOMIC | MI_ATOMIC_INC;
+	cmd[i++] = src_addr;
+	cmd[i++] = src_addr >> 32;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+	/* Punch a gap in the SVM map where we map the batch_bo */
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr,

batch_bo_size, 0);

tests/intel/xe_multi_gpusvm.c +27 -0
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
 static void batch_init(int fd, uint32_t vm, uint64_t src_addr,
 		       uint64_t dst_addr, uint64_t copy_size,
 		       uint32_t *bo, uint64_t *addr)
@@ -253,6 +312,51 @@ mgpu_check_fault_support(struct
 xe_svm_gpu_info *gpu1,
 	return ret;
 }
 
+static void
+gpu_madvise_sync(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t
 exec_queue,
+		 uint64_t dst_addr, uint64_t *batch_addr, unsigned int flags)
 {
+	struct drm_xe_sync sync = {};
+	uint64_t *sync_addr;
+
+	xe_multigpu_madvise(gpu->fd, vm, dst_addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu->fd, 0, gpu->vram_regions[0], exec_queue);
+
+	setup_sync(&sync, &sync_addr, BIND_SYNC_VAL);
+	xe_multigpu_prefetch(gpu->fd, vm, dst_addr, SZ_4K, &sync,
+			     sync_addr, exec_queue, flags);
+	free(sync_addr);
+
+	sync_addr = (void *)((char *)*batch_addr + SZ_4K);
+	sync.addr = to_user_pointer((uint64_t *)sync_addr);
+	sync.timeline_value = EXEC_SYNC_VAL;
+	WRITE_ONCE(*sync_addr, 0);
+
+	xe_exec_sync(gpu->fd, exec_queue, *batch_addr, &sync, 1);
+	if (READ_ONCE(*sync_addr) != EXEC_SYNC_VAL)
+		xe_wait_ufence(gpu->fd, (uint64_t *)sync_addr,

EXEC_SYNC_VAL, exec_queue,

tests/intel/xe_multi_gpusvm.c +5 -0
+			       NSEC_PER_SEC * 10);
+}
+
+static void
+gpu_batch_create(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t

exec_queue,

tests/intel/xe_multi_gpusvm.c +7 -0
+		 uint64_t src_addr, uint64_t dst_addr,
+		 uint32_t *batch_bo, uint64_t *batch_addr,
+		 unsigned int flags, int op_type)
+{
+	switch (op_type) {
+	case ATOMIC:
+		atomic_batch_init(gpu->fd, vm, src_addr, batch_bo,

batch_addr);

tests/intel/xe_multi_gpusvm.c +3 -0
+		break;
+	case INIT:
+		batch_init(gpu->fd, vm, src_addr, dst_addr, SZ_4K,

batch_bo, batch_addr);

tests/intel/xe_multi_gpusvm.c +64 -0
+		break;
+	default:
+		igt_assert(!"Unknown batch op_type");
+	}
+}
+
 static void
 copy_src_dst(struct xe_svm_gpu_info *gpu1,
 	     struct xe_svm_gpu_info *gpu2,
@@ -315,6 +419,87 @@ copy_src_dst(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);  }
 
+static void
+atomic_inc_op(struct xe_svm_gpu_info *gpu1,
+	      struct xe_svm_gpu_info *gpu2,
+	      struct drm_xe_engine_class_instance *eci,
+	      unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	struct test_exec_data *data;
+	uint64_t batch_addr[2];
+	void *copy_dst;
+	uint32_t final_value;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	data[0].vm_sync = 0;
+	addr = to_user_pointer(data);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	WRITE_ONCE(*(uint64_t *)addr, ATOMIC_OP_VAL - 1);
+
+	/* GPU1: Atomic Batch create */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, ATOMIC);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr,
 &batch_addr[0],
+flags);
+
+	/* GPU2 --> copy from GPU1 */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr,
 to_user_pointer(copy_dst),
+			 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1],
 to_user_pointer(copy_dst),
+			 &batch_addr[1], flags);
+
+	/* NOW CPU can read copy_dst (GPU2 ATOMIC op) */
+	final_value = *(uint32_t *)copy_dst;
+	igt_assert_eq(final_value, ATOMIC_OP_VAL);
+
+	/* GPU2: Atomic Batch create */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1],
 to_user_pointer(copy_dst), 0,
+			 &batch_bo[1], &batch_addr[1], flags, ATOMIC);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1],

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +4 -0
+			 &batch_addr[1], flags);
+
+	/* GPU1 --> copy from GPU2 */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0],

to_user_pointer(copy_dst), addr,

tests/intel/xe_multi_gpusvm.c +4 -0
+			 &batch_bo[0], &batch_addr[0], flags, INIT);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[1], addr,

&batch_addr[0],

tests/intel/xe_multi_gpusvm.c +28 -0
+flags);
+
+	/* NOW CPU can read addr (GPU1 ATOMIC op) */
+	final_value = *(uint32_t *)addr;
+	igt_assert_eq(final_value, ATOMIC_OP_VAL + 1);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -327,6 +512,18 @@ gpu_mem_access_wrapper(struct
 xe_svm_gpu_info *src,
 	copy_src_dst(src, dst, eci, flags);
 }
 
+static void
+gpu_atomic_inc_wrapper(struct xe_svm_gpu_info *src,
+		       struct xe_svm_gpu_info *dst,
+		       struct drm_xe_engine_class_instance *eci,
+		       unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	atomic_inc_op(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,

struct drm_xe_engine_class_instance *eci, @@ -334,6 +531,8
@@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus, {

tests/intel/xe_multi_gpusvm.c +0 -0
 	if (flags & MULTIGPU_XGPU_ACCESS)
 		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_mem_access_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (flags & MULTIGPU_ATOMIC_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_atomic_inc_wrapper, flags);
}

struct section {

tests/intel/xe_multi_gpusvm.c +2 -0
@@ -354,6 +553,8 @@ igt_main
 	const struct section msections[] = {
 		{ "xgpu-access-basic", MULTIGPU_XGPU_ACCESS },
 		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_XGPU_ACCESS },
+		{ "atomic-op-basic", MULTIGPU_ATOMIC_OP },
+		{ "atomic-op-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_ATOMIC_OP },
 		{ NULL },
tests/intel/xe_multi_gpusvm.c +0 -0
 	};

tests/intel/xe_multi_gpusvm.c igt_main

Quoted 9 lines
tests/intel/xe_multi_gpusvm.c +1 -2
@@ -377,7 +578,7 @@ igt_main
 		}
 	}
 
-	igt_describe("gpu-gpu write-read");
+	igt_describe("multigpu svm operations");
 	for (const struct section *s = msections; s->name; s++) {
 		igt_subtest_f("mgpu-%s", s->name)
 			test_mgpu_exec(gpu_cnt, gpus, &eci, s->flags);
--
Quoted 1 line

2.48.1

#12 lore raw

PATCH v9 5/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU coherency test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test verifies memory coherency in a multi-GPU environment using SVM. GPU 1 writes to a shared buffer, GPU 2 reads and checks for correct data without explicit synchronization, and the test is repeated with CPU and both GPUs to ensure consistent memory visibility across agents.

---
 tests/intel/xe_multi_gpusvm.c | 220 ++++++++++++++++++++++++++++++++++
 1 file changed, 220 insertions(+)
tests/intel/xe_multi_gpusvm.c +220 -0
index 1d126c740..6166795b3 100644
@@ -44,6 +44,26 @@
  *	Tests cross-GPU atomic increment operations with explicit memory prefetch
  *	to validate SVM atomic operations in multi-GPU config
  *
+ * SUBTEST: mgpu-coherency-basic
+ * Description:
+ *	Test basic cross-GPU memory coherency where one GPU writes data
+ *	and another GPU reads to verify coherent memory access without prefetch
+ *
+ * SUBTEST: mgpu-coherency-fail-basic
+ * Description:
+ *	Test concurrent write race conditions between GPUs to verify coherency
+ *	behavior when multiple GPUs write to the same memory location without prefetch
+ *
+ * SUBTEST: mgpu-coherency-prefetch
+ * Description:
+ *	Test cross-GPU memory coherency with explicit prefetch to validate
+ *	coherent memory access and migration across GPUs
+ *
+ * SUBTEST: mgpu-coherency-fail-prefetch
+ * Description:
+ *	Test concurrent write race conditions with prefetch to verify coherency
+ *	behavior and memory migration when multiple GPUs compete for same location
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -54,14 +74,18 @@
 #define EXEC_SYNC_VAL 0x676767
 #define COPY_SIZE SZ_64M
 #define	ATOMIC_OP_VAL	56
+#define BATCH_VALUE	60
 
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
 #define MULTIGPU_ATOMIC_OP		BIT(3)
+#define MULTIGPU_COH_OP			BIT(4)
+#define MULTIGPU_COH_FAIL		BIT(5)
 
 #define INIT	2
 #define STORE	3
 #define ATOMIC	4
+#define DWORD	5
 
 struct xe_svm_gpu_info {
 	bool supports_faults;
@@ -102,6 +126,11 @@ static void gpu_atomic_inc_wrapper(struct xe_svm_gpu_info *src,
 				   struct drm_xe_engine_class_instance *eci,
 				   unsigned int flags);
 
+static void gpu_coherecy_test_wrapper(struct xe_svm_gpu_info *src,
+				      struct xe_svm_gpu_info *dst,
+				      struct drm_xe_engine_class_instance *eci,
+				      unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
 		    uint32_t *vm, uint32_t *exec_queue)
@@ -218,6 +247,35 @@ atomic_batch_init(int fd, uint32_t vm, uint64_t src_addr,
 	*addr = batch_addr;
 }
 
+static void
+store_dword_batch_init(int fd, uint32_t vm, uint64_t src_addr,
+		       uint32_t *bo, uint64_t *addr, int value)
+{
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size, vram_if_possible(fd, 0), 0);
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *) batch;
+
+	cmd[i++] = MI_STORE_DWORD_IMM_GEN4;
+	cmd[i++] = src_addr;
+	cmd[i++] = src_addr >> 32;
+	cmd[i++] = value;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+
+	/* Punch a gap in the SVM map where we map the batch_bo */
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr, batch_bo_size, 0);
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
 static void batch_init(int fd, uint32_t vm, uint64_t src_addr,
 		       uint64_t dst_addr, uint64_t copy_size,
 		       uint32_t *bo, uint64_t *addr)
@@ -352,6 +410,9 @@ gpu_batch_create(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue,
 	case INIT:
 		batch_init(gpu->fd, vm, src_addr, dst_addr, SZ_4K, batch_bo, batch_addr);
 		break;
+	case DWORD:
+		store_dword_batch_init(gpu->fd, vm, src_addr, batch_bo, batch_addr, BATCH_VALUE);
+		break;
 	default:
 		igt_assert(!"Unknown batch op_type");
 	}
@@ -500,6 +561,146 @@ atomic_inc_op(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
 }
 
+static void
+coherency_test_multigpu(struct xe_svm_gpu_info *gpu1,
+			struct xe_svm_gpu_info *gpu2,
+			struct drm_xe_engine_class_instance *eci,
+			unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2], batch1_bo[2];
+	uint64_t batch_addr[2], batch1_addr[2];
+	uint64_t *data1;
+	void *copy_dst;
+	uint32_t final_value;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data1 = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data1);
+	addr = to_user_pointer(data1);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	/* GPU1: Creating batch with predefined value */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr, &batch_addr[0], flags);
+
+	/* NOW CPU can read add (GPU1 STORE op) */
+	final_value = READ_ONCE(*(uint32_t *)addr);
+	igt_debug("GPU1 written value: %u\n", final_value);
+
+	/* GPU2 --> copy from GPU1 */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, to_user_pointer(copy_dst),
+			 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+			 &batch_addr[1], flags);
+
+	/* verifying copy_dst (GPU2 INIT op) have correct value */
+	final_value = READ_ONCE(*(uint32_t *)copy_dst);
+	igt_assert_eq(final_value, BATCH_VALUE);
+
+	if (flags & MULTIGPU_COH_FAIL) {
+		struct drm_xe_sync sync0 = {}, sync1 = {};
+		uint64_t *result;
+		uint64_t coh_result;
+		uint64_t *sync_addr0, *sync_addr1;
+
+		igt_info("verifying concurrent write race\n");
+
+		WRITE_ONCE(*(uint64_t *)addr, 0);
+
+		store_dword_batch_init(gpu1->fd, vm[0], addr, &batch1_bo[0],
+				       &batch1_addr[0], BATCH_VALUE + 10);
+		store_dword_batch_init(gpu2->fd, vm[1], addr, &batch1_bo[1],
+				       &batch1_addr[1], BATCH_VALUE + 20);
+
+		/* Setup sync for GPU1 */
+		sync_addr0 = (void *)((char *)batch1_addr[0] + SZ_4K);
+		sync0.flags = DRM_XE_SYNC_FLAG_SIGNAL;
+		sync0.type = DRM_XE_SYNC_TYPE_USER_FENCE;
+		sync0.addr = to_user_pointer((uint64_t *)sync_addr0);
+		sync0.timeline_value = EXEC_SYNC_VAL;
+		WRITE_ONCE(*sync_addr0, 0);
+
+		/* Setup sync for GPU2 */
+		sync_addr1 = (void *)((char *)batch1_addr[1] + SZ_4K);
+		sync1.flags = DRM_XE_SYNC_FLAG_SIGNAL;
+		sync1.type = DRM_XE_SYNC_TYPE_USER_FENCE;
+		sync1.addr = to_user_pointer((uint64_t *)sync_addr1);
+		sync1.timeline_value = EXEC_SYNC_VAL;
+		WRITE_ONCE(*sync_addr1, 0);
+
+		/* Launch both concurrently - no wait between them */
+		xe_exec_sync(gpu1->fd, exec_queue[0], batch1_addr[0], &sync0, 1);
+		xe_exec_sync(gpu2->fd, exec_queue[1], batch1_addr[1], &sync1, 1);
+
+		/* Wait for both ops to complete */
+		if (READ_ONCE(*sync_addr0) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr0, EXEC_SYNC_VAL,
+				       exec_queue[0], NSEC_PER_SEC * 10);
+		if (READ_ONCE(*sync_addr1) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu2->fd, (uint64_t *)sync_addr1, EXEC_SYNC_VAL,
+				       exec_queue[1], NSEC_PER_SEC * 10);
+
+		/* Create result buffer for GPU to copy the final value */
+		result = aligned_alloc(SZ_2M, SZ_4K);
+		igt_assert(result);
+		WRITE_ONCE(*result, 0xDEADBEEF); // Initialize with known pattern
+
+		/* GPU2 --> copy from addr */
+		gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, to_user_pointer(result),
+				 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+		/*GPU2: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(result),
+				 &batch_addr[1], flags);
+
+		/* Check which write won (or if we got a mix) */
+		coh_result = READ_ONCE(*result);
+
+		if (coh_result == (BATCH_VALUE + 10))
+			igt_info("GPU1's write won the race\n");
+		else if (coh_result == (BATCH_VALUE + 20))
+			igt_info("GPU2's write won the race\n");
+		else if (coh_result == 0)
+			igt_warn("Both writes failed - coherency issue\n");
+		else
+			igt_warn("Unexpected value 0x%lx - possible coherency corruption\n",
+				 coh_result);
+
+		munmap((void *)batch1_addr[0], BATCH_SIZE(gpu1->fd));
+		munmap((void *)batch1_addr[1], BATCH_SIZE(gpu2->fd));
+
+		batch_fini(gpu1->fd, vm[0], batch1_bo[0], batch1_addr[0]);
+		batch_fini(gpu2->fd, vm[1], batch1_bo[1], batch1_addr[1]);
+		free(result);
+	}
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data1);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -524,6 +725,18 @@ gpu_atomic_inc_wrapper(struct xe_svm_gpu_info *src,
 	atomic_inc_op(src, dst, eci, flags);
 }
 
+static void
+gpu_coherecy_test_wrapper(struct xe_svm_gpu_info *src,
+			  struct xe_svm_gpu_info *dst,
+			  struct drm_xe_engine_class_instance *eci,
+			  unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	coherency_test_multigpu(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci,
@@ -533,6 +746,8 @@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_mem_access_wrapper, flags);
 	if (flags & MULTIGPU_ATOMIC_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_atomic_inc_wrapper, flags);
+	if (flags & MULTIGPU_COH_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_coherecy_test_wrapper, flags);
 }
 
 struct section {
@@ -555,6 +770,11 @@ igt_main
 		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_XGPU_ACCESS },
 		{ "atomic-op-basic", MULTIGPU_ATOMIC_OP },
 		{ "atomic-op-prefetch", MULTIGPU_PREFETCH | MULTIGPU_ATOMIC_OP },
+		{ "coherency-basic", MULTIGPU_COH_OP },
+		{ "coherency-fail-basic", MULTIGPU_COH_OP | MULTIGPU_COH_FAIL },
+		{ "coherency-prefetch", MULTIGPU_PREFETCH | MULTIGPU_COH_OP },
+		{ "coherency-fail-prefetch",
+		  MULTIGPU_PREFETCH | MULTIGPU_COH_OP | MULTIGPU_COH_FAIL},
 		{ NULL },
 	};
 
Signature · 1 line
2.48.1
Reviewed-by on v9 5/10
#13 lore raw

RE: [PATCH i-g-t v9 05/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU coherency test

Quoted 351 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 05/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU coherency test

From: Nishit Sharma <[email protected]>

This test verifies memory coherency in a multi-GPU environment using SVM. GPU 1 writes to a shared buffer, GPU 2 reads and checks for correct data without explicit synchronization, and the test is repeated with CPU and both GPUs to ensure consistent memory visibility across agents.

---
 tests/intel/xe_multi_gpusvm.c | 220
++++++++++++++++++++++++++++++++++
 1 file changed, 220 insertions(+)
tests/intel/xe_multi_gpusvm.c +0 -0
index 1d126c740..6166795b3 100644
@@ -44,6 +44,26 @@
  *	Tests cross-GPU atomic increment operations with explicit memory

prefetch
* to validate SVM atomic operations in multi-GPU config
*
+ * SUBTEST: mgpu-coherency-basic
+ * Description:
+ * Test basic cross-GPU memory coherency where one GPU writes data
+ * and another GPU reads to verify coherent memory access without
prefetch
+ *
+ * SUBTEST: mgpu-coherency-fail-basic
+ * Description:
+ * Test concurrent write race conditions between GPUs to verify
coherency
+ * behavior when multiple GPUs write to the same memory location
without prefetch
+ *
+ * SUBTEST: mgpu-coherency-prefetch
+ * Description:
+ * Test cross-GPU memory coherency with explicit prefetch to validate
+ * coherent memory access and migration across GPUs
+ *
+ * SUBTEST: mgpu-coherency-fail-prefetch
+ * Description:
+ * Test concurrent write race conditions with prefetch to verify
coherency
+ * behavior and memory migration when multiple GPUs compete for
same location
+ *
*/

#define MAX_XE_REGIONS 8

tests/intel/xe_multi_gpusvm.c +9 -0
@@ -54,14 +74,18 @@
 #define EXEC_SYNC_VAL 0x676767
 #define COPY_SIZE SZ_64M
 #define	ATOMIC_OP_VAL	56
+#define BATCH_VALUE	60
 
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
 #define MULTIGPU_ATOMIC_OP		BIT(3)
+#define MULTIGPU_COH_OP			BIT(4)
+#define MULTIGPU_COH_FAIL		BIT(5)
 
 #define INIT	2
 #define STORE	3
 #define ATOMIC	4
+#define DWORD	5
 
 struct xe_svm_gpu_info {
 	bool supports_faults;
@@ -102,6 +126,11 @@ static void gpu_atomic_inc_wrapper(struct
 xe_svm_gpu_info *src,
 				   struct drm_xe_engine_class_instance *eci,
 				   unsigned int flags);
 
+static void gpu_coherecy_test_wrapper(struct xe_svm_gpu_info *src,
+				      struct xe_svm_gpu_info *dst,
+				      struct drm_xe_engine_class_instance
 *eci,
+				      unsigned int flags);
+
 static void

create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct
drm_xe_engine_class_instance *eci,
uint32_t *vm, uint32_t *exec_queue) @@ -218,6 +247,35
@@ atomic_batch_init(int fd, uint32_t vm, uint64_t src_addr,

tests/intel/xe_multi_gpusvm.c +11 -0
 	*addr = batch_addr;
 }
 
+static void
+store_dword_batch_init(int fd, uint32_t vm, uint64_t src_addr,
+		       uint32_t *bo, uint64_t *addr, int value) {
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size,

vram_if_possible(fd, 0), 0);

tests/intel/xe_multi_gpusvm.c +13 -0
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *) batch;
+
+	cmd[i++] = MI_STORE_DWORD_IMM_GEN4;
+	cmd[i++] = src_addr;
+	cmd[i++] = src_addr >> 32;
+	cmd[i++] = value;
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+
+	/* Punch a gap in the SVM map where we map the batch_bo */
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr,

batch_bo_size, 0);

tests/intel/xe_multi_gpusvm.c +7 -0
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
 static void batch_init(int fd, uint32_t vm, uint64_t src_addr,
 		       uint64_t dst_addr, uint64_t copy_size,
 		       uint32_t *bo, uint64_t *addr)
@@ -352,6 +410,9 @@ gpu_batch_create(struct xe_svm_gpu_info *gpu,
 uint32_t vm, uint32_t exec_queue,
 	case INIT:
 		batch_init(gpu->fd, vm, src_addr, dst_addr, SZ_4K,
 batch_bo, batch_addr);
 		break;
+	case DWORD:
+		store_dword_batch_init(gpu->fd, vm, src_addr, batch_bo,
 batch_addr, BATCH_VALUE);
+		break;
tests/intel/xe_multi_gpusvm.c +66 -0
 	default:
 		igt_assert(!"Unknown batch op_type");
 	}
@@ -500,6 +561,146 @@ atomic_inc_op(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);  }
 
+static void
+coherency_test_multigpu(struct xe_svm_gpu_info *gpu1,
+			struct xe_svm_gpu_info *gpu2,
+			struct drm_xe_engine_class_instance *eci,
+			unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2], batch1_bo[2];
+	uint64_t batch_addr[2], batch1_addr[2];
+	uint64_t *data1;
+	void *copy_dst;
+	uint32_t final_value;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data1 = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data1);
+	addr = to_user_pointer(data1);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	/* GPU1: Creating batch with predefined value */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr,
 &batch_addr[0],
+flags);
+
+	/* NOW CPU can read add (GPU1 STORE op) */
+	final_value = READ_ONCE(*(uint32_t *)addr);
+	igt_debug("GPU1 written value: %u\n", final_value);
+
+	/* GPU2 --> copy from GPU1 */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr,
 to_user_pointer(copy_dst),
+			 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1],
 to_user_pointer(copy_dst),
+			 &batch_addr[1], flags);
+
+	/* verifying copy_dst (GPU2 INIT op) have correct value */
+	final_value = READ_ONCE(*(uint32_t *)copy_dst);
+	igt_assert_eq(final_value, BATCH_VALUE);
+
+	if (flags & MULTIGPU_COH_FAIL) {
+		struct drm_xe_sync sync0 = {}, sync1 = {};
+		uint64_t *result;
+		uint64_t coh_result;
+		uint64_t *sync_addr0, *sync_addr1;
+
+		igt_info("verifying concurrent write race\n");
+
+		WRITE_ONCE(*(uint64_t *)addr, 0);
+
+		store_dword_batch_init(gpu1->fd, vm[0], addr,
 &batch1_bo[0],
+				       &batch1_addr[0], BATCH_VALUE + 10);
+		store_dword_batch_init(gpu2->fd, vm[1], addr,

&batch1_bo[1],

tests/intel/xe_multi_gpusvm.c +20 -0
+				       &batch1_addr[1], BATCH_VALUE + 20);
+
+		/* Setup sync for GPU1 */
+		sync_addr0 = (void *)((char *)batch1_addr[0] + SZ_4K);
+		sync0.flags = DRM_XE_SYNC_FLAG_SIGNAL;
+		sync0.type = DRM_XE_SYNC_TYPE_USER_FENCE;
+		sync0.addr = to_user_pointer((uint64_t *)sync_addr0);
+		sync0.timeline_value = EXEC_SYNC_VAL;
+		WRITE_ONCE(*sync_addr0, 0);
+
+		/* Setup sync for GPU2 */
+		sync_addr1 = (void *)((char *)batch1_addr[1] + SZ_4K);
+		sync1.flags = DRM_XE_SYNC_FLAG_SIGNAL;
+		sync1.type = DRM_XE_SYNC_TYPE_USER_FENCE;
+		sync1.addr = to_user_pointer((uint64_t *)sync_addr1);
+		sync1.timeline_value = EXEC_SYNC_VAL;
+		WRITE_ONCE(*sync_addr1, 0);
+
+		/* Launch both concurrently - no wait between them */
+		xe_exec_sync(gpu1->fd, exec_queue[0], batch1_addr[0],

&sync0, 1);

tests/intel/xe_multi_gpusvm.c +1 -0
+		xe_exec_sync(gpu2->fd, exec_queue[1], batch1_addr[1],

&sync1, 1);

tests/intel/xe_multi_gpusvm.c +4 -0
+
+		/* Wait for both ops to complete */
+		if (READ_ONCE(*sync_addr0) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr0,

EXEC_SYNC_VAL,

tests/intel/xe_multi_gpusvm.c +3 -0
+				       exec_queue[0], NSEC_PER_SEC * 10);
+		if (READ_ONCE(*sync_addr1) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu2->fd, (uint64_t *)sync_addr1,

EXEC_SYNC_VAL,

tests/intel/xe_multi_gpusvm.c +6 -0
+				       exec_queue[1], NSEC_PER_SEC * 10);
+
+		/* Create result buffer for GPU to copy the final value */
+		result = aligned_alloc(SZ_2M, SZ_4K);
+		igt_assert(result);
+		WRITE_ONCE(*result, 0xDEADBEEF); // Initialize with known

pattern

tests/intel/xe_multi_gpusvm.c +3 -0
+
+		/* GPU2 --> copy from addr */
+		gpu_batch_create(gpu2, vm[1], exec_queue[1], addr,

to_user_pointer(result),

tests/intel/xe_multi_gpusvm.c +4 -0
+				 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+		/*GPU2: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu2, vm[1], exec_queue[1],

to_user_pointer(result),

tests/intel/xe_multi_gpusvm.c +13 -0
+				 &batch_addr[1], flags);
+
+		/* Check which write won (or if we got a mix) */
+		coh_result = READ_ONCE(*result);
+
+		if (coh_result == (BATCH_VALUE + 10))
+			igt_info("GPU1's write won the race\n");
+		else if (coh_result == (BATCH_VALUE + 20))
+			igt_info("GPU2's write won the race\n");
+		else if (coh_result == 0)
+			igt_warn("Both writes failed - coherency issue\n");
+		else
+			igt_warn("Unexpected value 0x%lx - possible

coherency corruption\n",

tests/intel/xe_multi_gpusvm.c +31 -0
+				 coh_result);
+
+		munmap((void *)batch1_addr[0], BATCH_SIZE(gpu1->fd));
+		munmap((void *)batch1_addr[1], BATCH_SIZE(gpu2->fd));
+
+		batch_fini(gpu1->fd, vm[0], batch1_bo[0], batch1_addr[0]);
+		batch_fini(gpu2->fd, vm[1], batch1_bo[1], batch1_addr[1]);
+		free(result);
+	}
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data1);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -524,6 +725,18 @@ gpu_atomic_inc_wrapper(struct xe_svm_gpu_info
 *src,
 	atomic_inc_op(src, dst, eci, flags);
 }
 
+static void
+gpu_coherecy_test_wrapper(struct xe_svm_gpu_info *src,
+			  struct xe_svm_gpu_info *dst,
+			  struct drm_xe_engine_class_instance *eci,
+			  unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	coherency_test_multigpu(src, dst, eci, flags); }
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci, @@ -533,6 +746,8

@@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
for_each_gpu_pair(gpu_cnt, gpus, eci,
gpu_mem_access_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +0 -0
 	if (flags & MULTIGPU_ATOMIC_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_atomic_inc_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (flags & MULTIGPU_COH_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_coherecy_test_wrapper,

tests/intel/xe_multi_gpusvm.c +4 -0
+flags);
 }
 
 struct section {
@@ -555,6 +770,11 @@ igt_main
 		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_XGPU_ACCESS },
 		{ "atomic-op-basic", MULTIGPU_ATOMIC_OP },
 		{ "atomic-op-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_ATOMIC_OP },
+		{ "coherency-basic", MULTIGPU_COH_OP },
+		{ "coherency-fail-basic", MULTIGPU_COH_OP |
 MULTIGPU_COH_FAIL },
+		{ "coherency-prefetch", MULTIGPU_PREFETCH |

MULTIGPU_COH_OP },

tests/intel/xe_multi_gpusvm.c +2 -0
+		{ "coherency-fail-prefetch",
+		  MULTIGPU_PREFETCH | MULTIGPU_COH_OP |

MULTIGPU_COH_FAIL},

tests/intel/xe_multi_gpusvm.c igt_main · line 779

Quoted 2 lines
tests/intel/xe_multi_gpusvm.c +0 -0
 		{ NULL },
 	};
Quoted 2 lines

--
2.48.1

#14 lore raw

PATCH v9 6/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU performance test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test measures latency and bandwidth for buffer access from each GPU and the CPU in a multi-GPU SVM environment. It compares performance for local versus remote access using madvise and prefetch to control buffer placement

---
 tests/intel/xe_multi_gpusvm.c | 244 +++++++++++++++++++++++++++++++++-
 1 file changed, 243 insertions(+), 1 deletion(-)
tests/intel/xe_multi_gpusvm.c +243 -1
index 6166795b3..efe3db099 100644
@@ -13,6 +13,8 @@
 #include "intel_mocs.h"
 #include "intel_reg.h"
 
+#include "time.h"
+
 #include "xe/xe_ioctl.h"
 #include "xe/xe_query.h"
 #include "xe/xe_util.h"
@@ -64,6 +66,26 @@
  *	Test concurrent write race conditions with prefetch to verify coherency
  *	behavior and memory migration when multiple GPUs compete for same location
  *
+ * SUBTEST: mgpu-latency-basic
+ * Description:
+ *	Measure basic cross-GPU memory access latency where one GPU writes
+ *	and another GPU reads without prefetch to evaluate remote access overhead
+ *
+ * SUBTEST: mgpu-latency-prefetch
+ * Description:
+ *	Measure cross-GPU memory access latency with explicit prefetch to
+ *	evaluate memory migration overhead and local access performance
+ *
+ * SUBTEST: mgpu-latency-copy-basic
+ * Description:
+ *	Measure latency of cross-GPU memory copy operations where one GPU
+ *	copies data from another GPU's memory without prefetch
+ *
+ * SUBTEST: mgpu-latency-copy-prefetch
+ * Description:
+ *	Measure latency of cross-GPU memory copy operations with prefetch
+ *	to evaluate copy performance with memory migration to local VRAM
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -81,12 +103,16 @@
 #define MULTIGPU_ATOMIC_OP		BIT(3)
 #define MULTIGPU_COH_OP			BIT(4)
 #define MULTIGPU_COH_FAIL		BIT(5)
+#define MULTIGPU_PERF_OP		BIT(6)
+#define MULTIGPU_PERF_REM_COPY		BIT(7)
 
 #define INIT	2
 #define STORE	3
 #define ATOMIC	4
 #define DWORD	5
 
+struct timespec t_start, t_end;
+
 struct xe_svm_gpu_info {
 	bool supports_faults;
 	int vram_regions[MAX_XE_REGIONS];
@@ -131,6 +157,11 @@ static void gpu_coherecy_test_wrapper(struct xe_svm_gpu_info *src,
 				      struct drm_xe_engine_class_instance *eci,
 				      unsigned int flags);
 
+static void gpu_latency_test_wrapper(struct xe_svm_gpu_info *src,
+				     struct xe_svm_gpu_info *dst,
+				     struct drm_xe_engine_class_instance *eci,
+				     unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
 		    uint32_t *vm, uint32_t *exec_queue)
@@ -220,6 +251,11 @@ static void for_each_gpu_pair(int num_gpus, struct xe_svm_gpu_info *gpus,
 
 static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);
 
+static double time_diff(struct timespec *start, struct timespec *end)
+{
+	return (end->tv_sec - start->tv_sec) + (end->tv_nsec - start->tv_nsec) / 1e9;
+}
+
 static void
 atomic_batch_init(int fd, uint32_t vm, uint64_t src_addr,
 		  uint32_t *bo, uint64_t *addr)
@@ -370,6 +406,39 @@ mgpu_check_fault_support(struct xe_svm_gpu_info *gpu1,
 	return ret;
 }
 
+static void
+store_dword_batch_init_4k(int fd, uint32_t vm, uint64_t src_addr,
+			  uint32_t *bo, uint64_t *addr, int value)
+{
+	int max_cmds = (4096 - sizeof(uint32_t)) / 16;
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size, vram_if_possible(fd, 0), 0);
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *)batch;
+
+	for (int j = 0; j < max_cmds; j++) {
+		uint64_t offset = src_addr + j * 4;
+
+		cmd[i++] = MI_STORE_DWORD_IMM_GEN4;
+		cmd[i++] = offset;
+		cmd[i++] = offset >> 32;
+		cmd[i++] = value;
+	}
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr, batch_bo_size, 0);
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
 static void
 gpu_madvise_sync(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue,
 		 uint64_t dst_addr, uint64_t *batch_addr, unsigned int flags)
@@ -391,10 +460,16 @@ gpu_madvise_sync(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue,
 	sync.timeline_value = EXEC_SYNC_VAL;
 	WRITE_ONCE(*sync_addr, 0);
 
+	if (flags & MULTIGPU_PERF_OP)
+		clock_gettime(CLOCK_MONOTONIC, &t_start);
+
 	xe_exec_sync(gpu->fd, exec_queue, *batch_addr, &sync, 1);
 	if (READ_ONCE(*sync_addr) != EXEC_SYNC_VAL)
 		xe_wait_ufence(gpu->fd, (uint64_t *)sync_addr, EXEC_SYNC_VAL, exec_queue,
 			       NSEC_PER_SEC * 10);
+
+	if (flags & MULTIGPU_PERF_OP)
+		clock_gettime(CLOCK_MONOTONIC, &t_end);
 }
 
 static void
@@ -411,7 +486,12 @@ gpu_batch_create(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t exec_queue,
 		batch_init(gpu->fd, vm, src_addr, dst_addr, SZ_4K, batch_bo, batch_addr);
 		break;
 	case DWORD:
-		store_dword_batch_init(gpu->fd, vm, src_addr, batch_bo, batch_addr, BATCH_VALUE);
+		if (flags & MULTIGPU_PERF_OP)
+			store_dword_batch_init_4k(gpu->fd, vm, src_addr, batch_bo,
+						  batch_addr,BATCH_VALUE);
+		else
+			store_dword_batch_init(gpu->fd, vm, src_addr, batch_bo,
+					       batch_addr, BATCH_VALUE);
 		break;
 	default:
 		igt_assert(!"Unknown batch op_type");
@@ -701,6 +781,148 @@ coherency_test_multigpu(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
 }
 
+static void
+latency_test_multigpu(struct xe_svm_gpu_info *gpu1,
+		      struct xe_svm_gpu_info *gpu2,
+		      struct drm_xe_engine_class_instance *eci,
+		      unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	uint8_t *copy_dst;
+	uint64_t batch_addr[2];
+	struct test_exec_data *data;
+	double gpu1_latency, gpu2_latency;
+	double gpu1_bw, gpu2_bw;
+	uint32_t final_value;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	data[0].vm_sync = 0;
+	addr = to_user_pointer(data);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	/* GPU1: Creating batch with predefined value */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr, &batch_addr[0], flags);
+
+	gpu1_latency = time_diff(&t_start, &t_end);
+	gpu1_bw = (SZ_4K / (gpu1_latency / 1e9)) / (1024.0 * 1024.0); //Written in 4K buffer
+
+	igt_info("GPU1 write with %s: Latency %.3f us, Bandwidth %.2f MB/s\n",
+		 (flags & MULTIGPU_PREFETCH) ? "prefetch" : "noprefetch",
+		 gpu1_latency / 1000.0, gpu1_bw);
+
+	/* Validate GPU1 performance */
+	if (flags & MULTIGPU_PREFETCH) {
+		if (gpu1_latency / 1000.0 > 5.0)
+			igt_warn("GPU1 write with prefetch slower than expected (%.3f us > 5us)\n",
+				 gpu1_latency / 1000.0);
+	}
+
+	if (flags & MULTIGPU_PERF_REM_COPY) {
+		/*GPU2: Copy data from addr (written by GPU1) to its own buffer (copy_dst) */
+		gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, to_user_pointer(copy_dst),
+				 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+		/*GPU2: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+				 &batch_addr[1], flags);
+
+		gpu2_latency = time_diff(&t_start, &t_end);
+		gpu2_bw = (SZ_4K / (gpu2_latency / 1e9)) / (1024.0 * 1024.0);
+		final_value = *(uint32_t *)copy_dst;
+		igt_assert_eq(final_value, BATCH_VALUE);
+	} else {
+		/* GPU1 --> Creating batch with value and executing STORE op */
+		gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+				 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+		/*GPU1: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr, &batch_addr[0], flags);
+
+		gpu2_latency = time_diff(&t_start, &t_end);
+
+		/*GPU2: Copy data from addr (written by GPU1) to its own buffer (copy_dst) */
+		gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, to_user_pointer(copy_dst),
+				 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+		/*GPU2: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+				 &batch_addr[1], flags);
+
+		gpu2_latency += time_diff(&t_start, &t_end);
+		gpu2_bw = (SZ_4K / (gpu2_latency / 1e9)) / (1024.0 * 1024.0);
+		final_value = READ_ONCE(*(uint32_t *)copy_dst);
+		igt_assert_eq(final_value, BATCH_VALUE);
+	}
+
+	igt_info("GPU2 %s copy: Latency %.3f us, Bandwidth %.2f MB/s\n",
+		 (flags & MULTIGPU_PERF_REM_COPY) ? "remote" : "local",
+		 gpu2_latency / 1000.0, gpu2_bw);
+
+	/* Validate GPU2 performance based on scenario */
+	if (flags & MULTIGPU_PERF_REM_COPY) {
+		if (flags & MULTIGPU_PREFETCH) {
+			/* Remote copy with prefetch: expect 0.2-1us */
+			if (gpu2_latency / 1000.0 > 1.0)
+				igt_warn("GPU2 remote copy with prefetch slower than expected (%.3f us > 1us)\n",
+					 gpu2_latency / 1000.0);
+		} else {
+			/* Remote copy without prefetch: expect 1-4us */
+			if (gpu2_latency / 1000.0 > 10.0)
+				igt_warn("GPU2 P2P remote copy is very slow (%.3f us > 10us)\n",
+					 gpu2_latency / 1000.0);
+		}
+	} else {
+		if (flags & MULTIGPU_PREFETCH) {
+			/* Local write with prefetch: expect 0.1-0.5us */
+			if (gpu2_latency / 1000.0 > 1.0)
+				igt_warn("GPU2 local write with prefetch slower than expected (%.3f us > 1us)\n",
+					 gpu2_latency / 1000.0);
+		}
+	}
+
+	/* Bandwidth comparison */
+	if (gpu2_bw > gpu1_bw)
+		igt_info("GPU2 has %.2fx better bandwidth than GPU1\n", gpu2_bw / gpu1_bw);
+	else
+		igt_info("GPU1 has %.2fx better bandwidth than GPU2\n", gpu1_bw / gpu2_bw);
+
+	/* Overall prefetch effectiveness check */
+	if (flags & MULTIGPU_PREFETCH) {
+		if ((gpu1_latency / 1000.0) < 5.0 && (gpu2_latency / 1000.0) < 5.0)
+			igt_info("Prefetch providing expected performance benefit\n");
+		else
+			igt_warn("Prefetch not providing expected performance benefit\n");
+	}
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -737,6 +959,18 @@ gpu_coherecy_test_wrapper(struct xe_svm_gpu_info *src,
 	coherency_test_multigpu(src, dst, eci, flags);
 }
 
+static void
+gpu_latency_test_wrapper(struct xe_svm_gpu_info *src,
+			 struct xe_svm_gpu_info *dst,
+			 struct drm_xe_engine_class_instance *eci,
+			 unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	latency_test_multigpu(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci,
@@ -748,6 +982,8 @@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_atomic_inc_wrapper, flags);
 	if (flags & MULTIGPU_COH_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_coherecy_test_wrapper, flags);
+	if (flags & MULTIGPU_PERF_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_latency_test_wrapper, flags);
 }
 
 struct section {
@@ -775,6 +1011,12 @@ igt_main
 		{ "coherency-prefetch", MULTIGPU_PREFETCH | MULTIGPU_COH_OP },
 		{ "coherency-fail-prefetch",
 		  MULTIGPU_PREFETCH | MULTIGPU_COH_OP | MULTIGPU_COH_FAIL},
+		{ "latency-basic", MULTIGPU_PERF_OP },
+		{ "latency-copy-basic",
+		  MULTIGPU_PERF_OP | MULTIGPU_PERF_REM_COPY },
+		{ "latency-prefetch", MULTIGPU_PREFETCH | MULTIGPU_PERF_OP },
+		{ "latency-copy-prefetch",
+		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP | MULTIGPU_PERF_REM_COPY },
 		{ NULL },
 	};
 
Signature · 1 line
2.48.1
Reviewed-by on v9 6/10
#15 lore raw

RE: [PATCH i-g-t v9 06/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU performance test

Quoted 413 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 06/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU performance test

From: Nishit Sharma <[email protected]>

This test measures latency and bandwidth for buffer access from each GPU and the CPU in a multi-GPU SVM environment. It compares performance for local versus remote access using madvise and prefetch to control buffer placement

---
 tests/intel/xe_multi_gpusvm.c | 244
+++++++++++++++++++++++++++++++++-
 1 file changed, 243 insertions(+), 1 deletion(-)
tests/intel/xe_multi_gpusvm.c +2 -0
index 6166795b3..efe3db099 100644
@@ -13,6 +13,8 @@
 #include "intel_mocs.h"
 #include "intel_reg.h"
 
+#include "time.h"
+
 #include "xe/xe_ioctl.h"
 #include "xe/xe_query.h"
 #include "xe/xe_util.h"
@@ -64,6 +66,26 @@
  *	Test concurrent write race conditions with prefetch to verify

coherency
* behavior and memory migration when multiple GPUs compete for
same location
*
+ * SUBTEST: mgpu-latency-basic
+ * Description:
+ * Measure basic cross-GPU memory access latency where one GPU
writes
+ * and another GPU reads without prefetch to evaluate remote access
overhead
+ *
+ * SUBTEST: mgpu-latency-prefetch
+ * Description:
+ * Measure cross-GPU memory access latency with explicit prefetch to
+ * evaluate memory migration overhead and local access performance
+ *
+ * SUBTEST: mgpu-latency-copy-basic
+ * Description:
+ * Measure latency of cross-GPU memory copy operations where one
GPU
+ * copies data from another GPU's memory without prefetch
+ *
+ * SUBTEST: mgpu-latency-copy-prefetch
+ * Description:
+ * Measure latency of cross-GPU memory copy operations with
prefetch
+ * to evaluate copy performance with memory migration to local VRAM
+ *
*/

#define MAX_XE_REGIONS 8

tests/intel/xe_multi_gpusvm.c +9 -0
@@ -81,12 +103,16 @@
 #define MULTIGPU_ATOMIC_OP		BIT(3)
 #define MULTIGPU_COH_OP			BIT(4)
 #define MULTIGPU_COH_FAIL		BIT(5)
+#define MULTIGPU_PERF_OP		BIT(6)
+#define MULTIGPU_PERF_REM_COPY		BIT(7)
 
 #define INIT	2
 #define STORE	3
 #define ATOMIC	4
 #define DWORD	5
 
+struct timespec t_start, t_end;
+
 struct xe_svm_gpu_info {
 	bool supports_faults;
 	int vram_regions[MAX_XE_REGIONS];
@@ -131,6 +157,11 @@ static void gpu_coherecy_test_wrapper(struct
 xe_svm_gpu_info *src,
 				      struct drm_xe_engine_class_instance
 *eci,
 				      unsigned int flags);
 
+static void gpu_latency_test_wrapper(struct xe_svm_gpu_info *src,
+				     struct xe_svm_gpu_info *dst,
+				     struct drm_xe_engine_class_instance *eci,
+				     unsigned int flags);
+
 static void

create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct
drm_xe_engine_class_instance *eci,
uint32_t *vm, uint32_t *exec_queue) @@ -220,6 +251,11
@@ static void for_each_gpu_pair(int num_gpus, struct xe_svm_gpu_info *gpus,

static void open_pagemaps(int fd, struct xe_svm_gpu_info *info);

tests/intel/xe_multi_gpusvm.c +2 -0
+static double time_diff(struct timespec *start, struct timespec *end) {
+	return (end->tv_sec - start->tv_sec) + (end->tv_nsec - start-
Quoted 1 line

tv_nsec)

tests/intel/xe_multi_gpusvm.c +34 -0
+/ 1e9; }
+
 static void
 atomic_batch_init(int fd, uint32_t vm, uint64_t src_addr,
 		  uint32_t *bo, uint64_t *addr)
@@ -370,6 +406,39 @@ mgpu_check_fault_support(struct
 xe_svm_gpu_info *gpu1,
 	return ret;
 }
 
+static void
+store_dword_batch_init_4k(int fd, uint32_t vm, uint64_t src_addr,
+			  uint32_t *bo, uint64_t *addr, int value) {
+	int max_cmds = (4096 - sizeof(uint32_t)) / 16;
+	uint32_t batch_bo_size = BATCH_SIZE(fd);
+	uint32_t batch_bo;
+	uint64_t batch_addr;
+	void *batch;
+	uint32_t *cmd;
+	int i = 0;
+
+	batch_bo = xe_bo_create(fd, vm, batch_bo_size,
 vram_if_possible(fd, 0), 0);
+	batch = xe_bo_map(fd, batch_bo, batch_bo_size);
+	cmd = (uint32_t *)batch;
+
+	for (int j = 0; j < max_cmds; j++) {
+		uint64_t offset = src_addr + j * 4;
+
+		cmd[i++] = MI_STORE_DWORD_IMM_GEN4;
+		cmd[i++] = offset;
+		cmd[i++] = offset >> 32;
+		cmd[i++] = value;
+	}
+	cmd[i++] = MI_BATCH_BUFFER_END;
+
+	batch_addr = to_user_pointer(batch);
+
+	xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr,
 batch_bo_size, 0);
+	*bo = batch_bo;
+	*addr = batch_addr;
+}
+
 static void
 gpu_madvise_sync(struct xe_svm_gpu_info *gpu, uint32_t vm, uint32_t

exec_queue,

tests/intel/xe_multi_gpusvm.c +6 -0
 		 uint64_t dst_addr, uint64_t *batch_addr, unsigned int flags)
@@ -391,10 +460,16 @@ gpu_madvise_sync(struct xe_svm_gpu_info *gpu,
 uint32_t vm, uint32_t exec_queue,
 	sync.timeline_value = EXEC_SYNC_VAL;
 	WRITE_ONCE(*sync_addr, 0);
 
+	if (flags & MULTIGPU_PERF_OP)
+		clock_gettime(CLOCK_MONOTONIC, &t_start);
+
 	xe_exec_sync(gpu->fd, exec_queue, *batch_addr, &sync, 1);
 	if (READ_ONCE(*sync_addr) != EXEC_SYNC_VAL)
 		xe_wait_ufence(gpu->fd, (uint64_t *)sync_addr,
 EXEC_SYNC_VAL, exec_queue,
 			       NSEC_PER_SEC * 10);
+
+	if (flags & MULTIGPU_PERF_OP)
+		clock_gettime(CLOCK_MONOTONIC, &t_end);
 }

static void

tests/intel/xe_multi_gpusvm.c +2 -1
@@ -411,7 +486,12 @@ gpu_batch_create(struct xe_svm_gpu_info *gpu,
 uint32_t vm, uint32_t exec_queue,
 		batch_init(gpu->fd, vm, src_addr, dst_addr, SZ_4K,
 batch_bo, batch_addr);
 		break;
 	case DWORD:
-		store_dword_batch_init(gpu->fd, vm, src_addr, batch_bo,
 batch_addr, BATCH_VALUE);
+		if (flags & MULTIGPU_PERF_OP)
+			store_dword_batch_init_4k(gpu->fd, vm, src_addr,

batch_bo,

tests/intel/xe_multi_gpusvm.c +3 -0
+						  batch_addr,BATCH_VALUE);
+		else
+			store_dword_batch_init(gpu->fd, vm, src_addr,

batch_bo,

tests/intel/xe_multi_gpusvm.c +1 -0
+					       batch_addr, BATCH_VALUE);
 		break;
 	default:
 		igt_assert(!"Unknown batch op_type"); @@ -701,6 +781,148

@@ coherency_test_multigpu(struct xe_svm_gpu_info *gpu1,

tests/intel/xe_multi_gpusvm.c +38 -0
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);  }
 
+static void
+latency_test_multigpu(struct xe_svm_gpu_info *gpu1,
+		      struct xe_svm_gpu_info *gpu2,
+		      struct drm_xe_engine_class_instance *eci,
+		      unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	uint8_t *copy_dst;
+	uint64_t batch_addr[2];
+	struct test_exec_data *data;
+	double gpu1_latency, gpu2_latency;
+	double gpu1_bw, gpu2_bw;
+	uint32_t final_value;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	data[0].vm_sync = 0;
+	addr = to_user_pointer(data);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	/* GPU1: Creating batch with predefined value */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr,

&batch_addr[0],

tests/intel/xe_multi_gpusvm.c +7 -0
+flags);
+
+	gpu1_latency = time_diff(&t_start, &t_end);
+	gpu1_bw = (SZ_4K / (gpu1_latency / 1e9)) / (1024.0 * 1024.0);
+//Written in 4K buffer
+
+	igt_info("GPU1 write with %s: Latency %.3f us, Bandwidth %.2f

MB/s\n",

tests/intel/xe_multi_gpusvm.c +7 -0
+		 (flags & MULTIGPU_PREFETCH) ? "prefetch" : "noprefetch",
+		 gpu1_latency / 1000.0, gpu1_bw);
+
+	/* Validate GPU1 performance */
+	if (flags & MULTIGPU_PREFETCH) {
+		if (gpu1_latency / 1000.0 > 5.0)
+			igt_warn("GPU1 write with prefetch slower than

expected (%.3f us > 5us)\n",

tests/intel/xe_multi_gpusvm.c +5 -0
+				 gpu1_latency / 1000.0);
+	}
+
+	if (flags & MULTIGPU_PERF_REM_COPY) {
+		/*GPU2: Copy data from addr (written by GPU1) to its own

buffer (copy_dst) */

tests/intel/xe_multi_gpusvm.c +1 -0
+		gpu_batch_create(gpu2, vm[1], exec_queue[1], addr,

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +4 -0
+				 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+		/*GPU2: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu2, vm[1], exec_queue[1],

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +8 -0
+				 &batch_addr[1], flags);
+
+		gpu2_latency = time_diff(&t_start, &t_end);
+		gpu2_bw = (SZ_4K / (gpu2_latency / 1e9)) / (1024.0 * 1024.0);
+		final_value = *(uint32_t *)copy_dst;
+		igt_assert_eq(final_value, BATCH_VALUE);
+	} else {
+		/* GPU1 --> Creating batch with value and executing STORE

op */

tests/intel/xe_multi_gpusvm.c +2 -0
+		gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+				 &batch_bo[0], &batch_addr[0], flags,

DWORD);

tests/intel/xe_multi_gpusvm.c +3 -0
+
+		/*GPU1: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr,

&batch_addr[0],

tests/intel/xe_multi_gpusvm.c +5 -0
+flags);
+
+		gpu2_latency = time_diff(&t_start, &t_end);
+
+		/*GPU2: Copy data from addr (written by GPU1) to its own

buffer (copy_dst) */

tests/intel/xe_multi_gpusvm.c +1 -0
+		gpu_batch_create(gpu2, vm[1], exec_queue[1], addr,

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +4 -0
+				 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+		/*GPU2: Madvise and Prefetch Ops */
+		gpu_madvise_sync(gpu2, vm[1], exec_queue[1],

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +18 -0
+				 &batch_addr[1], flags);
+
+		gpu2_latency += time_diff(&t_start, &t_end);
+		gpu2_bw = (SZ_4K / (gpu2_latency / 1e9)) / (1024.0 * 1024.0);
+		final_value = READ_ONCE(*(uint32_t *)copy_dst);
+		igt_assert_eq(final_value, BATCH_VALUE);
+	}
+
+	igt_info("GPU2 %s copy: Latency %.3f us, Bandwidth %.2f MB/s\n",
+		 (flags & MULTIGPU_PERF_REM_COPY) ? "remote" : "local",
+		 gpu2_latency / 1000.0, gpu2_bw);
+
+	/* Validate GPU2 performance based on scenario */
+	if (flags & MULTIGPU_PERF_REM_COPY) {
+		if (flags & MULTIGPU_PREFETCH) {
+			/* Remote copy with prefetch: expect 0.2-1us */
+			if (gpu2_latency / 1000.0 > 1.0)
+				igt_warn("GPU2 remote copy with prefetch

slower than expected (%.3f us > 1us)\n",

tests/intel/xe_multi_gpusvm.c +5 -0
+					 gpu2_latency / 1000.0);
+		} else {
+			/* Remote copy without prefetch: expect 1-4us */
+			if (gpu2_latency / 1000.0 > 10.0)
+				igt_warn("GPU2 P2P remote copy is very

slow (%.3f us > 10us)\n",

tests/intel/xe_multi_gpusvm.c +7 -0
+					 gpu2_latency / 1000.0);
+		}
+	} else {
+		if (flags & MULTIGPU_PREFETCH) {
+			/* Local write with prefetch: expect 0.1-0.5us */
+			if (gpu2_latency / 1000.0 > 1.0)
+				igt_warn("GPU2 local write with prefetch

slower than expected (%.3f us > 1us)\n",

tests/intel/xe_multi_gpusvm.c +7 -0
+					 gpu2_latency / 1000.0);
+		}
+	}
+
+	/* Bandwidth comparison */
+	if (gpu2_bw > gpu1_bw)
+		igt_info("GPU2 has %.2fx better bandwidth than GPU1\n",

gpu2_bw / gpu1_bw);

tests/intel/xe_multi_gpusvm.c +2 -0
+	else
+		igt_info("GPU1 has %.2fx better bandwidth than GPU2\n",

gpu1_bw /

tests/intel/xe_multi_gpusvm.c +5 -0
+gpu2_bw);
+
+	/* Overall prefetch effectiveness check */
+	if (flags & MULTIGPU_PREFETCH) {
+		if ((gpu1_latency / 1000.0) < 5.0 && (gpu2_latency / 1000.0) <

5.0)

tests/intel/xe_multi_gpusvm.c +1 -0
+			igt_info("Prefetch providing expected performance

benefit\n");

tests/intel/xe_multi_gpusvm.c +2 -0
+		else
+			igt_warn("Prefetch not providing expected

performance benefit\n");

tests/intel/xe_multi_gpusvm.c +24 -0
+	}
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -737,6 +959,18 @@ gpu_coherecy_test_wrapper(struct
 xe_svm_gpu_info *src,
 	coherency_test_multigpu(src, dst, eci, flags);  }
 
+static void
+gpu_latency_test_wrapper(struct xe_svm_gpu_info *src,
+			 struct xe_svm_gpu_info *dst,
+			 struct drm_xe_engine_class_instance *eci,
+			 unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	latency_test_multigpu(src, dst, eci, flags); }
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci, @@ -748,6 +982,8

@@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
for_each_gpu_pair(gpu_cnt, gpus, eci,
gpu_atomic_inc_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +0 -0
 	if (flags & MULTIGPU_COH_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_coherecy_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (flags & MULTIGPU_PERF_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_latency_test_wrapper,

tests/intel/xe_multi_gpusvm.c +7 -0
+flags);
 }
 
 struct section {
@@ -775,6 +1011,12 @@ igt_main
 		{ "coherency-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_COH_OP },
 		{ "coherency-fail-prefetch",
 		  MULTIGPU_PREFETCH | MULTIGPU_COH_OP |
 MULTIGPU_COH_FAIL},
+		{ "latency-basic", MULTIGPU_PERF_OP },
+		{ "latency-copy-basic",
+		  MULTIGPU_PERF_OP | MULTIGPU_PERF_REM_COPY },
+		{ "latency-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_PERF_OP },
+		{ "latency-copy-prefetch",
+		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP |

MULTIGPU_PERF_REM_COPY },

tests/intel/xe_multi_gpusvm.c igt_main · line 1021

Quoted 2 lines
tests/intel/xe_multi_gpusvm.c +0 -0
 		{ NULL },
 	};
Quoted 2 lines

--
2.48.1

#16 lore raw

PATCH v9 7/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU fault handling test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test intentionally triggers page faults by accessing regions without prefetch for both GPUs in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 151 ++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)
tests/intel/xe_multi_gpusvm.c +151 -0
index efe3db099..7a06e289c 100644
@@ -15,6 +15,7 @@
 
 #include "time.h"
 
+#include "xe/xe_gt.h"
 #include "xe/xe_ioctl.h"
 #include "xe/xe_query.h"
 #include "xe/xe_util.h"
@@ -86,6 +87,17 @@
  *	Measure latency of cross-GPU memory copy operations with prefetch
  *	to evaluate copy performance with memory migration to local VRAM
  *
+ * SUBTEST: mgpu-pagefault-basic
+ * Description:
+ *	Test cross-GPU page fault handling where one GPU writes to memory
+ *	and another GPU reads, triggering page faults without prefetch to
+ *	validate on-demand page migration across GPUs
+ *
+ * SUBTEST: mgpu-pagefault-prefetch
+ * Description:
+ *	Test cross-GPU memory access with prefetch to verify page fault
+ *	suppression when memory is pre-migrated to target GPU's VRAM
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -105,6 +117,7 @@
 #define MULTIGPU_COH_FAIL		BIT(5)
 #define MULTIGPU_PERF_OP		BIT(6)
 #define MULTIGPU_PERF_REM_COPY		BIT(7)
+#define MULTIGPU_PFAULT_OP		BIT(8)
 
 #define INIT	2
 #define STORE	3
@@ -162,6 +175,11 @@ static void gpu_latency_test_wrapper(struct xe_svm_gpu_info *src,
 				     struct drm_xe_engine_class_instance *eci,
 				     unsigned int flags);
 
+static void gpu_fault_test_wrapper(struct xe_svm_gpu_info *src,
+				   struct xe_svm_gpu_info *dst,
+				   struct drm_xe_engine_class_instance *eci,
+				   unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
 		    uint32_t *vm, uint32_t *exec_queue)
@@ -923,6 +941,123 @@ latency_test_multigpu(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
 }
 
+static void
+pagefault_test_multigpu(struct xe_svm_gpu_info *gpu1,
+			struct xe_svm_gpu_info *gpu2,
+			struct drm_xe_engine_class_instance *eci,
+			unsigned int flags)
+{
+	uint64_t addr;
+	uint64_t addr1;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	uint64_t batch_addr[2];
+	struct drm_xe_sync sync = {};
+	uint64_t *sync_addr;
+	uint32_t final_result;
+	void *data, *verify_result;
+	const char *pf_count_stat = "svm_pagefault_count";
+	int pf_count_gpu1_before, pf_count_gpu1_after;
+	int pf_count_gpu2_before, pf_count_gpu2_after;
+	bool prefetch_req = flags & MULTIGPU_PREFETCH;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	memset(data, 0, SZ_4K);
+	addr = to_user_pointer(data);
+
+	/* Allocate verification buffer for GPU2 to copy into */
+	verify_result = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(verify_result);
+	addr1 = to_user_pointer(verify_result);
+
+	/* === Phase 1: GPU1 writes to addr === */
+	pf_count_gpu1_before = xe_gt_stats_get_count(gpu1->fd, eci->gt_id, pf_count_stat);
+
+	/* GPU1 --> Creating batch with value and executing STORE op */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr, &batch_addr[0], flags);
+
+	pf_count_gpu1_after = xe_gt_stats_get_count(gpu1->fd, eci->gt_id, pf_count_stat);
+
+	if (prefetch_req) {
+		/* With prefetch: expect NO page faults */
+		igt_assert_eq(pf_count_gpu1_after, pf_count_gpu1_before);
+		igt_info("GPU1 write with prefetch: No page faults (as expected)\n");
+	} else {
+		/* Without prefetch: expect page faults */
+		igt_warn_on_f(pf_count_gpu1_after > pf_count_gpu1_before,
+			      "%d page faults generated on GPU1\n",
+			      pf_count_gpu1_after - pf_count_gpu1_before);
+		igt_info("GPU1 write without prefetch: %d page faults\n",
+			 pf_count_gpu1_after - pf_count_gpu1_before);
+	}
+
+	final_result = READ_ONCE(*(uint32_t *)addr);
+	igt_debug("GPU1 wrote :%u\n", final_result);
+
+	/* === Phase 2: GPU2 reads from addr (cross-GPU access) === */
+	pf_count_gpu2_before = xe_gt_stats_get_count(gpu2->fd, eci->gt_id, pf_count_stat);
+
+	/* GPU2 --> Create batch for GPU2 to copy from addr (GPU1's memory) to verify_result */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, addr1,
+			 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+	/* Prefetch src buffer (addr) to avoid page faults */
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0], exec_queue[1]);
+
+	setup_sync(&sync, &sync_addr, BIND_SYNC_VAL);
+	xe_multigpu_prefetch(gpu2->fd, vm[1], addr, SZ_4K, &sync,
+			     sync_addr, exec_queue[1], flags);
+
+	free(sync_addr);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], addr1, &batch_addr[1], flags);
+
+	pf_count_gpu2_after = xe_gt_stats_get_count(gpu2->fd, eci->gt_id, pf_count_stat);
+
+	if (prefetch_req) {
+		/* With prefetch: expect NO page faults on GPU2 */
+		igt_assert_eq(pf_count_gpu2_after, pf_count_gpu2_before);
+		igt_info("GPU2 cross-GPU read with prefetch: No page faults (as expected)\n");
+	} else {
+		/* Without prefetch: expect cross-GPU page faults */
+		igt_warn_on_f(pf_count_gpu2_after > pf_count_gpu2_before,
+			      "%d page faults generated on GPU2\n",
+			      pf_count_gpu2_after - pf_count_gpu2_before);
+		igt_info("GPU2 cross-GPU read without prefetch: %d page faults\n",
+			 pf_count_gpu2_after - pf_count_gpu2_before);
+	}
+
+	/* NOW CPU can safely read verify_result (not addr!) */
+	final_result = READ_ONCE(*(uint32_t *)addr1);
+	igt_assert_eq(final_result, BATCH_VALUE);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[0]);
+	free(data);
+	free(verify_result);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -971,6 +1106,18 @@ gpu_latency_test_wrapper(struct xe_svm_gpu_info *src,
 	latency_test_multigpu(src, dst, eci, flags);
 }
 
+static void
+gpu_fault_test_wrapper(struct xe_svm_gpu_info *src,
+		       struct xe_svm_gpu_info *dst,
+		       struct drm_xe_engine_class_instance *eci,
+		       unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	pagefault_test_multigpu(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci,
@@ -984,6 +1131,8 @@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_coherecy_test_wrapper, flags);
 	if (flags & MULTIGPU_PERF_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_latency_test_wrapper, flags);
+	if (flags & MULTIGPU_PFAULT_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_fault_test_wrapper, flags);
 }
 
 struct section {
@@ -1017,6 +1166,8 @@ igt_main
 		{ "latency-prefetch", MULTIGPU_PREFETCH | MULTIGPU_PERF_OP },
 		{ "latency-copy-prefetch",
 		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP | MULTIGPU_PERF_REM_COPY },
+		{ "pagefault-basic", MULTIGPU_PFAULT_OP },
+		{ "pagefault-prefetch", MULTIGPU_PREFETCH | MULTIGPU_PFAULT_OP },
 		{ NULL },
 	};
 
Signature · 1 line
2.48.1
Reviewed-by on v9 7/10
#17 lore raw

RE: [PATCH i-g-t v9 07/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU fault handling test

Quoted 257 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 07/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU fault handling test

From: Nishit Sharma <[email protected]>

This test intentionally triggers page faults by accessing regions without prefetch for both GPUs in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 151
++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)
tests/intel/xe_multi_gpusvm.c +1 -0
index efe3db099..7a06e289c 100644
@@ -15,6 +15,7 @@
 
 #include "time.h"
 
+#include "xe/xe_gt.h"
 #include "xe/xe_ioctl.h"
 #include "xe/xe_query.h"
 #include "xe/xe_util.h"
@@ -86,6 +87,17 @@
  *	Measure latency of cross-GPU memory copy operations with

prefetch
* to evaluate copy performance with memory migration to local VRAM
*
+ * SUBTEST: mgpu-pagefault-basic
+ * Description:
+ * Test cross-GPU page fault handling where one GPU writes to
memory
+ * and another GPU reads, triggering page faults without prefetch to
+ * validate on-demand page migration across GPUs
+ *
+ * SUBTEST: mgpu-pagefault-prefetch
+ * Description:
+ * Test cross-GPU memory access with prefetch to verify page fault
+ * suppression when memory is pre-migrated to target GPU's VRAM
+ *
*/

#define MAX_XE_REGIONS 8

tests/intel/xe_multi_gpusvm.c +6 -0
@@ -105,6 +117,7 @@
 #define MULTIGPU_COH_FAIL		BIT(5)
 #define MULTIGPU_PERF_OP		BIT(6)
 #define MULTIGPU_PERF_REM_COPY		BIT(7)
+#define MULTIGPU_PFAULT_OP		BIT(8)
 
 #define INIT	2
 #define STORE	3
@@ -162,6 +175,11 @@ static void gpu_latency_test_wrapper(struct
 xe_svm_gpu_info *src,
 				     struct drm_xe_engine_class_instance *eci,
 				     unsigned int flags);
 
+static void gpu_fault_test_wrapper(struct xe_svm_gpu_info *src,
+				   struct xe_svm_gpu_info *dst,
+				   struct drm_xe_engine_class_instance *eci,
+				   unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct

drm_xe_engine_class_instance *eci,
uint32_t *vm, uint32_t *exec_queue) @@ -923,6 +941,123
@@ latency_test_multigpu(struct xe_svm_gpu_info *gpu1,

tests/intel/xe_multi_gpusvm.c +40 -0
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);  }
 
+static void
+pagefault_test_multigpu(struct xe_svm_gpu_info *gpu1,
+			struct xe_svm_gpu_info *gpu2,
+			struct drm_xe_engine_class_instance *eci,
+			unsigned int flags)
+{
+	uint64_t addr;
+	uint64_t addr1;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	uint64_t batch_addr[2];
+	struct drm_xe_sync sync = {};
+	uint64_t *sync_addr;
+	uint32_t final_result;
+	void *data, *verify_result;
+	const char *pf_count_stat = "svm_pagefault_count";
+	int pf_count_gpu1_before, pf_count_gpu1_after;
+	int pf_count_gpu2_before, pf_count_gpu2_after;
+	bool prefetch_req = flags & MULTIGPU_PREFETCH;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	memset(data, 0, SZ_4K);
+	addr = to_user_pointer(data);
+
+	/* Allocate verification buffer for GPU2 to copy into */
+	verify_result = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(verify_result);
+	addr1 = to_user_pointer(verify_result);
+
+	/* === Phase 1: GPU1 writes to addr === */
+	pf_count_gpu1_before = xe_gt_stats_get_count(gpu1->fd, eci-
Quoted 1 line

gt_id,

tests/intel/xe_multi_gpusvm.c +8 -0
+pf_count_stat);
+
+	/* GPU1 --> Creating batch with value and executing STORE op */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, DWORD);
+
+	/*GPU1: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr,

&batch_addr[0],

tests/intel/xe_multi_gpusvm.c +8 -0
+flags);
+
+	pf_count_gpu1_after = xe_gt_stats_get_count(gpu1->fd, eci->gt_id,
+pf_count_stat);
+
+	if (prefetch_req) {
+		/* With prefetch: expect NO page faults */
+		igt_assert_eq(pf_count_gpu1_after,

pf_count_gpu1_before);

tests/intel/xe_multi_gpusvm.c +1 -0
+		igt_info("GPU1 write with prefetch: No page faults (as

expected)\n");

tests/intel/xe_multi_gpusvm.c +3 -0
+	} else {
+		/* Without prefetch: expect page faults */
+		igt_warn_on_f(pf_count_gpu1_after >

pf_count_gpu1_before,

tests/intel/xe_multi_gpusvm.c +11 -0
+			      "%d page faults generated on GPU1\n",
+			      pf_count_gpu1_after - pf_count_gpu1_before);
+		igt_info("GPU1 write without prefetch: %d page faults\n",
+			 pf_count_gpu1_after - pf_count_gpu1_before);
+	}
+
+	final_result = READ_ONCE(*(uint32_t *)addr);
+	igt_debug("GPU1 wrote :%u\n", final_result);
+
+	/* === Phase 2: GPU2 reads from addr (cross-GPU access) === */
+	pf_count_gpu2_before = xe_gt_stats_get_count(gpu2->fd, eci-
Quoted 1 line

gt_id,

tests/intel/xe_multi_gpusvm.c +3 -0
+pf_count_stat);
+
+	/* GPU2 --> Create batch for GPU2 to copy from addr (GPU1's

memory) to verify_result */

tests/intel/xe_multi_gpusvm.c +7 -0
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, addr1,
+			 &batch_bo[1], &batch_addr[1], flags, INIT);
+
+	/* Prefetch src buffer (addr) to avoid page faults */
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0],

exec_queue[1]);

tests/intel/xe_multi_gpusvm.c +9 -0
+
+	setup_sync(&sync, &sync_addr, BIND_SYNC_VAL);
+	xe_multigpu_prefetch(gpu2->fd, vm[1], addr, SZ_4K, &sync,
+			     sync_addr, exec_queue[1], flags);
+
+	free(sync_addr);
+
+	/*GPU2: Madvise and Prefetch Ops */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], addr1,

&batch_addr[1],

tests/intel/xe_multi_gpusvm.c +8 -0
+flags);
+
+	pf_count_gpu2_after = xe_gt_stats_get_count(gpu2->fd, eci->gt_id,
+pf_count_stat);
+
+	if (prefetch_req) {
+		/* With prefetch: expect NO page faults on GPU2 */
+		igt_assert_eq(pf_count_gpu2_after,

pf_count_gpu2_before);

tests/intel/xe_multi_gpusvm.c +1 -0
+		igt_info("GPU2 cross-GPU read with prefetch: No page faults

(as expected)\n");

tests/intel/xe_multi_gpusvm.c +3 -0
+	} else {
+		/* Without prefetch: expect cross-GPU page faults */
+		igt_warn_on_f(pf_count_gpu2_after >

pf_count_gpu2_before,

tests/intel/xe_multi_gpusvm.c +3 -0
+			      "%d page faults generated on GPU2\n",
+			      pf_count_gpu2_after - pf_count_gpu2_before);
+		igt_info("GPU2 cross-GPU read without prefetch: %d page

faults\n",

tests/intel/xe_multi_gpusvm.c +28 -0
+			 pf_count_gpu2_after - pf_count_gpu2_before);
+	}
+
+	/* NOW CPU can safely read verify_result (not addr!) */
+	final_result = READ_ONCE(*(uint32_t *)addr1);
+	igt_assert_eq(final_result, BATCH_VALUE);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[0]);
+	free(data);
+	free(verify_result);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -971,6 +1106,18 @@ gpu_latency_test_wrapper(struct
 xe_svm_gpu_info *src,
 	latency_test_multigpu(src, dst, eci, flags);  }
 
+static void
+gpu_fault_test_wrapper(struct xe_svm_gpu_info *src,
+		       struct xe_svm_gpu_info *dst,
+		       struct drm_xe_engine_class_instance *eci,
+		       unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	pagefault_test_multigpu(src, dst, eci, flags); }
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci, @@ -984,6 +1131,8

@@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
for_each_gpu_pair(gpu_cnt, gpus, eci,
gpu_coherecy_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +0 -0
 	if (flags & MULTIGPU_PERF_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_latency_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (flags & MULTIGPU_PFAULT_OP)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_fault_test_wrapper, flags);
}

struct section {

tests/intel/xe_multi_gpusvm.c +2 -0
@@ -1017,6 +1166,8 @@ igt_main
 		{ "latency-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_PERF_OP },
 		{ "latency-copy-prefetch",
 		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP |
 MULTIGPU_PERF_REM_COPY },
+		{ "pagefault-basic", MULTIGPU_PFAULT_OP },
+		{ "pagefault-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_PFAULT_OP },

tests/intel/xe_multi_gpusvm.c igt_main · line 1172

Quoted 2 lines
tests/intel/xe_multi_gpusvm.c +0 -0
 		{ NULL },
 	};
Quoted 2 lines

--
2.48.1

#18 lore raw

PATCH v9 8/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU simultaneous access test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test launches compute or copy workloads on both GPUs that access the same SVM buffer, using synchronization primitives (fences/semaphores) to coordinate access. It verifies data integrity and checks for the absence of race conditions in a multi-GPU SVM environment.

---
 tests/intel/xe_multi_gpusvm.c | 193 ++++++++++++++++++++++++++++++++++
 1 file changed, 193 insertions(+)
tests/intel/xe_multi_gpusvm.c +193 -0
index 7a06e289c..bdbaa7a16 100644
@@ -13,6 +13,7 @@
 #include "intel_mocs.h"
 #include "intel_reg.h"
 
+#include "intel_gpu_commands.h"
 #include "time.h"
 
 #include "xe/xe_gt.h"
@@ -98,6 +99,17 @@
  *	Test cross-GPU memory access with prefetch to verify page fault
  *	suppression when memory is pre-migrated to target GPU's VRAM
  *
+ * SUBTEST: mgpu-concurrent-access-basic
+ * Description:
+ *	Test concurrent atomic memory operations where multiple GPUs
+ *	simultaneously access and modify the same memory location without
+ *	prefetch to validate cross-GPU coherency and synchronization
+ *
+ * SUBTEST: mgpu-concurrent-access-prefetch
+ * Description:
+ *	Test concurrent atomic memory operations with prefetch where
+ *	multiple GPUs simultaneously access shared memory to validate
+ *	coherency with memory migration and local VRAM access
  */
 
 #define MAX_XE_REGIONS	8
@@ -109,6 +121,7 @@
 #define COPY_SIZE SZ_64M
 #define	ATOMIC_OP_VAL	56
 #define BATCH_VALUE	60
+#define NUM_ITER	200
 
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
@@ -118,6 +131,7 @@
 #define MULTIGPU_PERF_OP		BIT(6)
 #define MULTIGPU_PERF_REM_COPY		BIT(7)
 #define MULTIGPU_PFAULT_OP		BIT(8)
+#define MULTIGPU_CONC_ACCESS		BIT(9)
 
 #define INIT	2
 #define STORE	3
@@ -180,6 +194,11 @@ static void gpu_fault_test_wrapper(struct xe_svm_gpu_info *src,
 				   struct drm_xe_engine_class_instance *eci,
 				   unsigned int flags);
 
+static void gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
+				    struct xe_svm_gpu_info *dst,
+				    struct drm_xe_engine_class_instance *eci,
+				    unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
 		    uint32_t *vm, uint32_t *exec_queue)
@@ -1058,6 +1077,164 @@ pagefault_test_multigpu(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
 }
 
+static void
+multigpu_access_test(struct xe_svm_gpu_info *gpu1,
+		     struct xe_svm_gpu_info *gpu2,
+		     struct drm_xe_engine_class_instance *eci,
+		     unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	struct test_exec_data *data;
+	uint64_t batch_addr[2];
+	struct drm_xe_sync sync[2] = {};
+	uint64_t *sync_addr[2];
+	uint32_t verify_batch_bo;
+	uint64_t verify_batch_addr;
+	uint64_t *verify_result;
+	uint32_t final_value;
+	uint64_t final_timeline;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	data[0].vm_sync = 0;
+	addr = to_user_pointer(data);
+
+	WRITE_ONCE(*(uint64_t *)addr, 0);
+
+	/* GPU1: Atomic Batch create */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, ATOMIC);
+	/* GPU2: Atomic Batch create */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, 0,
+			 &batch_bo[1], &batch_addr[1], flags, ATOMIC);
+
+	/* gpu_madvise_sync calls xe_exec() also, here intention is different */
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_ATOMIC,
+			    DRM_XE_ATOMIC_GLOBAL, 0, 0, exec_queue[0]);
+
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu1->fd, 0, gpu1->vram_regions[0], exec_queue[0]);
+
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_ATOMIC,
+			    DRM_XE_ATOMIC_GLOBAL, 0, 0, exec_queue[1]);
+
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0], exec_queue[1]);
+
+	setup_sync(&sync[0], &sync_addr[0], BIND_SYNC_VAL);
+	setup_sync(&sync[1], &sync_addr[1], BIND_SYNC_VAL);
+
+	xe_multigpu_prefetch(gpu1->fd, vm[0], addr, SZ_4K, &sync[0],
+			     sync_addr[0], exec_queue[0], flags);
+
+	xe_multigpu_prefetch(gpu2->fd, vm[1], addr, SZ_4K, &sync[1],
+			     sync_addr[1], exec_queue[1], flags);
+
+	free(sync_addr[0]);
+	free(sync_addr[1]);
+
+	igt_info("Starting %d concurrent atomic increment iterations\n", NUM_ITER);
+	for (int i = 0; i < NUM_ITER; i++) {
+		bool last = (i == NUM_ITER - 1);
+
+		if (last) {
+			sync_addr[0] = (void *)((char *)batch_addr[0] + SZ_4K);
+			sync[0].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+			sync[0].type = DRM_XE_SYNC_TYPE_USER_FENCE;
+			sync[0].addr = to_user_pointer((uint64_t *)sync_addr[0]);
+			sync[0].timeline_value = EXEC_SYNC_VAL + i;
+			WRITE_ONCE(*sync_addr[0], 0);
+
+			sync_addr[1] = (void *)((char *)batch_addr[1] + SZ_4K);
+			sync[1].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+			sync[1].type = DRM_XE_SYNC_TYPE_USER_FENCE;
+			sync[1].addr = to_user_pointer((uint64_t *)sync_addr[1]);
+			sync[1].timeline_value = EXEC_SYNC_VAL + i;
+			WRITE_ONCE(*sync_addr[1], 0);
+		}
+
+		/* === CONCURRENT EXECUTION: Launch both GPUs simultaneously === */
+		xe_exec_sync(gpu1->fd, exec_queue[0], batch_addr[0],
+			     last ? &sync[0] : NULL, last ? 1 : 0);
+
+		xe_exec_sync(gpu2->fd, exec_queue[1], batch_addr[1],
+			     last ? &sync[1] : NULL, last ? 1 : 0);
+	}
+
+	 /* NOW wait only for the last operations to complete */
+	final_timeline = EXEC_SYNC_VAL + NUM_ITER - 1;
+	if (NUM_ITER > 0) {
+		if (READ_ONCE(*sync_addr[0]) != final_timeline)
+			xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr[0], final_timeline,
+				       exec_queue[0], NSEC_PER_SEC * 30);
+
+		if (READ_ONCE(*sync_addr[1]) != final_timeline)
+			xe_wait_ufence(gpu2->fd, (uint64_t *)sync_addr[1], final_timeline,
+				       exec_queue[1], NSEC_PER_SEC * 30);
+	}
+
+	igt_info("Both GPUs completed execution %u\n", READ_ONCE(*(uint32_t *)addr));
+
+	/* === Verification using GPU read (not CPU) === */
+	verify_result = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(verify_result);
+	memset(verify_result, 0xDE, SZ_4K);
+
+	/* Use GPU1 to read final value */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, to_user_pointer(verify_result),
+			 &verify_batch_bo, &verify_batch_addr, flags, INIT);
+
+	sync_addr[0] = (void *)((char *)verify_batch_addr + SZ_4K);
+	sync[0].addr = to_user_pointer((uint64_t *)sync_addr[0]);
+	sync[0].timeline_value = EXEC_SYNC_VAL;
+	sync[0].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+	sync[0].type = DRM_XE_SYNC_TYPE_USER_FENCE;
+	WRITE_ONCE(*sync_addr[0], 0);
+
+	xe_exec_sync(gpu1->fd, exec_queue[0], verify_batch_addr, &sync[0], 1);
+	if (READ_ONCE(*sync_addr[0]) != EXEC_SYNC_VAL)
+		xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr[0], EXEC_SYNC_VAL,
+			       exec_queue[0], NSEC_PER_SEC * 10);
+
+	/* NOW CPU can read verify_result */
+	final_value = READ_ONCE(*(uint32_t *)verify_result);
+
+	igt_info("GPU verification batch copied value: %u\n", final_value);
+	igt_info("CPU direct read shows: %u\n", (unsigned int)*(uint64_t *)addr);
+
+	/* Expected: 0 + (NUM_ITER * 2 GPUs) = 400 */
+	igt_assert_f((final_value == 2 * NUM_ITER),
+		     "Expected %u value, got %u\n",
+		     2 * NUM_ITER, final_value);
+
+	munmap((void *)verify_batch_addr, BATCH_SIZE(gpu1->fd));
+	batch_fini(gpu1->fd, vm[0], verify_batch_bo, verify_batch_addr);
+	free(verify_result);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -1118,6 +1295,18 @@ gpu_fault_test_wrapper(struct xe_svm_gpu_info *src,
 	pagefault_test_multigpu(src, dst, eci, flags);
 }
 
+static void
+gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
+			struct xe_svm_gpu_info *dst,
+			struct drm_xe_engine_class_instance *eci,
+			unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	multigpu_access_test(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci,
@@ -1133,6 +1322,8 @@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_latency_test_wrapper, flags);
 	if (flags & MULTIGPU_PFAULT_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_fault_test_wrapper, flags);
+	if (flags & MULTIGPU_CONC_ACCESS)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_simult_test_wrapper, flags);
 }
 
 struct section {
@@ -1168,6 +1359,8 @@ igt_main
 		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP | MULTIGPU_PERF_REM_COPY },
 		{ "pagefault-basic", MULTIGPU_PFAULT_OP },
 		{ "pagefault-prefetch", MULTIGPU_PREFETCH | MULTIGPU_PFAULT_OP },
+		{ "concurrent-access-basic", MULTIGPU_CONC_ACCESS },
+		{ "concurrent-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_CONC_ACCESS },
 		{ NULL },
 	};
 
Signature · 1 line
2.48.1
Reviewed-by on v9 8/10
#19 lore raw

RE: [PATCH i-g-t v9 08/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU simultaneous access test

Quoted 298 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 08/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU simultaneous access test

From: Nishit Sharma <[email protected]>

This test launches compute or copy workloads on both GPUs that access the same SVM buffer, using synchronization primitives (fences/semaphores) to coordinate access. It verifies data integrity and checks for the absence of race conditions in a multi-GPU SVM environment.

---
 tests/intel/xe_multi_gpusvm.c | 193
++++++++++++++++++++++++++++++++++
 1 file changed, 193 insertions(+)
tests/intel/xe_multi_gpusvm.c +5 -0
index 7a06e289c..bdbaa7a16 100644
@@ -13,6 +13,7 @@
 #include "intel_mocs.h"
 #include "intel_reg.h"
 
+#include "intel_gpu_commands.h"
 #include "time.h"
 
 #include "xe/xe_gt.h"
@@ -98,6 +99,17 @@
  *	Test cross-GPU memory access with prefetch to verify page fault
  *	suppression when memory is pre-migrated to target GPU's VRAM
  *
+ * SUBTEST: mgpu-concurrent-access-basic
+ * Description:
+ *	Test concurrent atomic memory operations where multiple GPUs
+ *	simultaneously access and modify the same memory location

without
+ * prefetch to validate cross-GPU coherency and synchronization
+ *
+ * SUBTEST: mgpu-concurrent-access-prefetch
+ * Description:
+ * Test concurrent atomic memory operations with prefetch where
+ * multiple GPUs simultaneously access shared memory to validate
+ * coherency with memory migration and local VRAM access
*/

#define MAX_XE_REGIONS 8

tests/intel/xe_multi_gpusvm.c +7 -0
@@ -109,6 +121,7 @@
 #define COPY_SIZE SZ_64M
 #define	ATOMIC_OP_VAL	56
 #define BATCH_VALUE	60
+#define NUM_ITER	200
 
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
@@ -118,6 +131,7 @@
 #define MULTIGPU_PERF_OP		BIT(6)
 #define MULTIGPU_PERF_REM_COPY		BIT(7)
 #define MULTIGPU_PFAULT_OP		BIT(8)
+#define MULTIGPU_CONC_ACCESS		BIT(9)
 
 #define INIT	2
 #define STORE	3
@@ -180,6 +194,11 @@ static void gpu_fault_test_wrapper(struct
 xe_svm_gpu_info *src,
 				   struct drm_xe_engine_class_instance *eci,
 				   unsigned int flags);
 
+static void gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
+				    struct xe_svm_gpu_info *dst,
+				    struct drm_xe_engine_class_instance *eci,
+				    unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct

drm_xe_engine_class_instance *eci,

tests/intel/xe_multi_gpusvm.c +43 -0
 		    uint32_t *vm, uint32_t *exec_queue) @@ -1058,6
+1077,164 @@ pagefault_test_multigpu(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);  }
 
+static void
+multigpu_access_test(struct xe_svm_gpu_info *gpu1,
+		     struct xe_svm_gpu_info *gpu2,
+		     struct drm_xe_engine_class_instance *eci,
+		     unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	struct test_exec_data *data;
+	uint64_t batch_addr[2];
+	struct drm_xe_sync sync[2] = {};
+	uint64_t *sync_addr[2];
+	uint32_t verify_batch_bo;
+	uint64_t verify_batch_addr;
+	uint64_t *verify_result;
+	uint32_t final_value;
+	uint64_t final_timeline;
+
+	/* Skip if either GPU doesn't support faults */
+	if (mgpu_check_fault_support(gpu1, gpu2))
+		return;
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	data[0].vm_sync = 0;
+	addr = to_user_pointer(data);
+
+	WRITE_ONCE(*(uint64_t *)addr, 0);
+
+	/* GPU1: Atomic Batch create */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr, 0,
+			 &batch_bo[0], &batch_addr[0], flags, ATOMIC);
+	/* GPU2: Atomic Batch create */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, 0,
+			 &batch_bo[1], &batch_addr[1], flags, ATOMIC);
+
+	/* gpu_madvise_sync calls xe_exec() also, here intention is different

*/

tests/intel/xe_multi_gpusvm.c +7 -0
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_ATOMIC,
+			    DRM_XE_ATOMIC_GLOBAL, 0, 0, exec_queue[0]);
+
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu1->fd, 0, gpu1->vram_regions[0],

exec_queue[0]);

tests/intel/xe_multi_gpusvm.c +8 -0
+
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_ATOMIC,
+			    DRM_XE_ATOMIC_GLOBAL, 0, 0, exec_queue[1]);
+
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K, 0,
+			    DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0],

exec_queue[1]);

tests/intel/xe_multi_gpusvm.c +14 -0
+
+	setup_sync(&sync[0], &sync_addr[0], BIND_SYNC_VAL);
+	setup_sync(&sync[1], &sync_addr[1], BIND_SYNC_VAL);
+
+	xe_multigpu_prefetch(gpu1->fd, vm[0], addr, SZ_4K, &sync[0],
+			     sync_addr[0], exec_queue[0], flags);
+
+	xe_multigpu_prefetch(gpu2->fd, vm[1], addr, SZ_4K, &sync[1],
+			     sync_addr[1], exec_queue[1], flags);
+
+	free(sync_addr[0]);
+	free(sync_addr[1]);
+
+	igt_info("Starting %d concurrent atomic increment iterations\n",

NUM_ITER);

tests/intel/xe_multi_gpusvm.c +5 -0
+	for (int i = 0; i < NUM_ITER; i++) {
+		bool last = (i == NUM_ITER - 1);
+
+		if (last) {
+			sync_addr[0] = (void *)((char *)batch_addr[0] +

SZ_4K);

tests/intel/xe_multi_gpusvm.c +3 -0
+			sync[0].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+			sync[0].type = DRM_XE_SYNC_TYPE_USER_FENCE;
+			sync[0].addr = to_user_pointer((uint64_t

*)sync_addr[0]);

tests/intel/xe_multi_gpusvm.c +4 -0
+			sync[0].timeline_value = EXEC_SYNC_VAL + i;
+			WRITE_ONCE(*sync_addr[0], 0);
+
+			sync_addr[1] = (void *)((char *)batch_addr[1] +

SZ_4K);

tests/intel/xe_multi_gpusvm.c +3 -0
+			sync[1].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+			sync[1].type = DRM_XE_SYNC_TYPE_USER_FENCE;
+			sync[1].addr = to_user_pointer((uint64_t

*)sync_addr[1]);

tests/intel/xe_multi_gpusvm.c +5 -0
+			sync[1].timeline_value = EXEC_SYNC_VAL + i;
+			WRITE_ONCE(*sync_addr[1], 0);
+		}
+
+		/* === CONCURRENT EXECUTION: Launch both GPUs

simultaneously === */

tests/intel/xe_multi_gpusvm.c +12 -0
+		xe_exec_sync(gpu1->fd, exec_queue[0], batch_addr[0],
+			     last ? &sync[0] : NULL, last ? 1 : 0);
+
+		xe_exec_sync(gpu2->fd, exec_queue[1], batch_addr[1],
+			     last ? &sync[1] : NULL, last ? 1 : 0);
+	}
+
+	 /* NOW wait only for the last operations to complete */
+	final_timeline = EXEC_SYNC_VAL + NUM_ITER - 1;
+	if (NUM_ITER > 0) {
+		if (READ_ONCE(*sync_addr[0]) != final_timeline)
+			xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr[0],

final_timeline,

tests/intel/xe_multi_gpusvm.c +4 -0
+				       exec_queue[0], NSEC_PER_SEC * 30);
+
+		if (READ_ONCE(*sync_addr[1]) != final_timeline)
+			xe_wait_ufence(gpu2->fd, (uint64_t *)sync_addr[1],

final_timeline,

tests/intel/xe_multi_gpusvm.c +4 -0
+				       exec_queue[1], NSEC_PER_SEC * 30);
+	}
+
+	igt_info("Both GPUs completed execution %u\n",

READ_ONCE(*(uint32_t

tests/intel/xe_multi_gpusvm.c +9 -0
+*)addr));
+
+	/* === Verification using GPU read (not CPU) === */
+	verify_result = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(verify_result);
+	memset(verify_result, 0xDE, SZ_4K);
+
+	/* Use GPU1 to read final value */
+	gpu_batch_create(gpu1, vm[0], exec_queue[0], addr,

to_user_pointer(verify_result),

tests/intel/xe_multi_gpusvm.c +10 -0
+			 &verify_batch_bo, &verify_batch_addr, flags, INIT);
+
+	sync_addr[0] = (void *)((char *)verify_batch_addr + SZ_4K);
+	sync[0].addr = to_user_pointer((uint64_t *)sync_addr[0]);
+	sync[0].timeline_value = EXEC_SYNC_VAL;
+	sync[0].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+	sync[0].type = DRM_XE_SYNC_TYPE_USER_FENCE;
+	WRITE_ONCE(*sync_addr[0], 0);
+
+	xe_exec_sync(gpu1->fd, exec_queue[0], verify_batch_addr,

&sync[0], 1);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (READ_ONCE(*sync_addr[0]) != EXEC_SYNC_VAL)
+		xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr[0],

EXEC_SYNC_VAL,

tests/intel/xe_multi_gpusvm.c +38 -0
+			       exec_queue[0], NSEC_PER_SEC * 10);
+
+	/* NOW CPU can read verify_result */
+	final_value = READ_ONCE(*(uint32_t *)verify_result);
+
+	igt_info("GPU verification batch copied value: %u\n", final_value);
+	igt_info("CPU direct read shows: %u\n", (unsigned int)*(uint64_t
+*)addr);
+
+	/* Expected: 0 + (NUM_ITER * 2 GPUs) = 400 */
+	igt_assert_f((final_value == 2 * NUM_ITER),
+		     "Expected %u value, got %u\n",
+		     2 * NUM_ITER, final_value);
+
+	munmap((void *)verify_batch_addr, BATCH_SIZE(gpu1->fd));
+	batch_fini(gpu1->fd, vm[0], verify_batch_bo, verify_batch_addr);
+	free(verify_result);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -1118,6 +1295,18 @@ gpu_fault_test_wrapper(struct xe_svm_gpu_info
 *src,
 	pagefault_test_multigpu(src, dst, eci, flags);  }
 
+static void
+gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
+			struct xe_svm_gpu_info *dst,
+			struct drm_xe_engine_class_instance *eci,
+			unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	multigpu_access_test(src, dst, eci, flags); }
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci, @@ -1133,6 +1322,8

@@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
for_each_gpu_pair(gpu_cnt, gpus, eci,
gpu_latency_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +0 -0
 	if (flags & MULTIGPU_PFAULT_OP)
 		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_fault_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (flags & MULTIGPU_CONC_ACCESS)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_simult_test_wrapper,

tests/intel/xe_multi_gpusvm.c +1 -0
+flags);
 }
 
 struct section {

tests/intel/xe_multi_gpusvm.c igt_main

Quoted 10 lines
tests/intel/xe_multi_gpusvm.c +3 -0
@@ -1168,6 +1359,8 @@ igt_main
 		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP |
 MULTIGPU_PERF_REM_COPY },
 		{ "pagefault-basic", MULTIGPU_PFAULT_OP },
 		{ "pagefault-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_PFAULT_OP },
+		{ "concurrent-access-basic", MULTIGPU_CONC_ACCESS },
+		{ "concurrent-access-prefetch", MULTIGPU_PREFETCH |
+MULTIGPU_CONC_ACCESS },
 		{ NULL },
 	};
Quoted 2 lines

--
2.48.1

#20 lore raw

PATCH v9 9/10 tests/intel/xe_multi_gpusvm: Add SVM multi-GPU conflicting madvise test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test calls madvise operations on GPU0 with the preferred location set to GPU1 and vice versa. It reports conflicts when conflicting memory advice is given for shared SVM buffers in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 143 ++++++++++++++++++++++++++++++++++
 1 file changed, 143 insertions(+)
tests/intel/xe_multi_gpusvm.c +143 -0
index bdbaa7a16..688ee0757 100644
@@ -110,6 +110,23 @@
  *	Test concurrent atomic memory operations with prefetch where
  *	multiple GPUs simultaneously access shared memory to validate
  *	coherency with memory migration and local VRAM access
+ *
+ * SUBTEST: mgpu-atomic-op-conflict
+ * Description:
+ *	Multi-GPU atomic operation with conflicting madvise regions
+ *
+ * SUBTEST: mgpu-coherency-conflict
+ * Description:
+ *	Multi-GPU coherency test with conflicting madvise regions
+ *
+ * SUBTEST: mgpu-concurrent-access-conflict
+ * Description:
+ *	Multi-GPU concurrent access with conflicting madvise regions
+ *
+ * SUBTEST: mgpu-pagefault-conflict
+ * Description:
+ *	Multi-GPU page fault test with conflicting madvise regions
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -123,6 +140,9 @@
 #define BATCH_VALUE	60
 #define NUM_ITER	200
 
+#define USER_FENCE_VALUE        0xdeadbeefdeadbeefull
+#define FIVE_SEC                (5LL * NSEC_PER_SEC)
+
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
 #define MULTIGPU_ATOMIC_OP		BIT(3)
@@ -132,6 +152,7 @@
 #define MULTIGPU_PERF_REM_COPY		BIT(7)
 #define MULTIGPU_PFAULT_OP		BIT(8)
 #define MULTIGPU_CONC_ACCESS		BIT(9)
+#define MULTIGPU_CONFLICT		BIT(10)
 
 #define INIT	2
 #define STORE	3
@@ -199,6 +220,12 @@ static void gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
 				    struct drm_xe_engine_class_instance *eci,
 				    unsigned int flags);
 
+static void
+conflicting_madvise(struct xe_svm_gpu_info *gpu1,
+		    struct xe_svm_gpu_info *gpu2,
+		    struct drm_xe_engine_class_instance *eci,
+		    unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct drm_xe_engine_class_instance *eci,
 		    uint32_t *vm, uint32_t *exec_queue)
@@ -616,6 +643,11 @@ atomic_inc_op(struct xe_svm_gpu_info *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
 
@@ -697,6 +729,11 @@ coherency_test_multigpu(struct xe_svm_gpu_info *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
 
@@ -985,6 +1022,11 @@ pagefault_test_multigpu(struct xe_svm_gpu_info *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
 
@@ -1101,6 +1143,11 @@ multigpu_access_test(struct xe_svm_gpu_info *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
 
@@ -1235,6 +1282,98 @@ multigpu_access_test(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
 }
 
+static void
+conflicting_madvise(struct xe_svm_gpu_info *gpu1,
+		    struct xe_svm_gpu_info *gpu2,
+		    struct drm_xe_engine_class_instance *eci,
+		    unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	void *data;
+	uint64_t batch_addr[2];
+	struct drm_xe_sync sync[2] = {};
+	uint64_t *sync_addr[2];
+
+	/* Skip if either GPU doesn't support faults */
+	if (!gpu1->supports_faults || !gpu2->supports_faults) {
+		igt_debug("Both GPUs must support page faults for this test\n");
+		return;
+	}
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	addr = to_user_pointer(data);
+
+	store_dword_batch_init(gpu1->fd, vm[0], addr, &batch_bo[0], &batch_addr[0], 10);
+	store_dword_batch_init(gpu2->fd, vm[1], addr, &batch_bo[1], &batch_addr[1], 20);
+
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM, 0, 0, exec_queue[0]);
+
+	igt_info("Testing GPU1 VM trying to prefer GPU2's VRAM (should fail)\n");
+
+	/* This SHOULD fail - GPU1's VM cannot prefer GPU2's VRAM */
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0], exec_queue[0]);
+
+	/* This SHOULD also fail - GPU2's VM cannot prefer GPU1's VRAM */
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu1->fd, 0, gpu1->vram_regions[0], exec_queue[0]);
+
+	setup_sync(&sync[0], &sync_addr[0], BIND_SYNC_VAL);
+	setup_sync(&sync[1], &sync_addr[1], BIND_SYNC_VAL);
+
+	/* For simultaneous access need to call xe_wait_ufence for both gpus after prefetch */
+	xe_multigpu_prefetch(gpu1->fd, vm[0], addr, SZ_4K, &sync[0],
+			     sync_addr[0], exec_queue[0], flags);
+	free(sync_addr[0]);
+
+	xe_multigpu_prefetch(gpu2->fd, vm[1], addr, SZ_4K, &sync[1],
+			     sync_addr[1], exec_queue[1], flags);
+	free(sync_addr[1]);
+
+	for (int i = 0; i < NUM_ITER; i++) {
+		sync_addr[0] = (void *)((char *)batch_addr[0] + SZ_4K);
+		sync[0].addr = to_user_pointer((uint64_t *)sync_addr[0]);
+		sync[0].timeline_value = EXEC_SYNC_VAL;
+
+		sync_addr[1] = (void *)((char *)batch_addr[1] + SZ_4K);
+		sync[1].addr = to_user_pointer((uint64_t *)sync_addr[1]);
+		sync[1].timeline_value = EXEC_SYNC_VAL;
+		WRITE_ONCE(*sync_addr[0], 0);
+		WRITE_ONCE(*sync_addr[1], 0);
+
+		xe_exec_sync(gpu1->fd, exec_queue[0], batch_addr[0], &sync[0], 1);
+		if (READ_ONCE(*sync_addr[0]) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr[0], EXEC_SYNC_VAL,
+				       exec_queue[0], NSEC_PER_SEC * 10);
+		xe_exec_sync(gpu2->fd, exec_queue[1], batch_addr[1], &sync[1], 1);
+		if (READ_ONCE(*sync_addr[1]) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu2->fd, (uint64_t *)sync_addr[1], EXEC_SYNC_VAL,
+				       exec_queue[1], NSEC_PER_SEC * 10);
+	}
+
+	igt_assert_eq(READ_ONCE(*(uint64_t *)addr), 20);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -1346,9 +1485,11 @@ igt_main
 		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_XGPU_ACCESS },
 		{ "atomic-op-basic", MULTIGPU_ATOMIC_OP },
 		{ "atomic-op-prefetch", MULTIGPU_PREFETCH | MULTIGPU_ATOMIC_OP },
+		{ "atomic-op-conflict", MULTIGPU_CONFLICT | MULTIGPU_ATOMIC_OP },
 		{ "coherency-basic", MULTIGPU_COH_OP },
 		{ "coherency-fail-basic", MULTIGPU_COH_OP | MULTIGPU_COH_FAIL },
 		{ "coherency-prefetch", MULTIGPU_PREFETCH | MULTIGPU_COH_OP },
+		{ "coherency-conflict", MULTIGPU_CONFLICT | MULTIGPU_COH_OP },
 		{ "coherency-fail-prefetch",
 		  MULTIGPU_PREFETCH | MULTIGPU_COH_OP | MULTIGPU_COH_FAIL},
 		{ "latency-basic", MULTIGPU_PERF_OP },
@@ -1359,8 +1500,10 @@ igt_main
 		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP | MULTIGPU_PERF_REM_COPY },
 		{ "pagefault-basic", MULTIGPU_PFAULT_OP },
 		{ "pagefault-prefetch", MULTIGPU_PREFETCH | MULTIGPU_PFAULT_OP },
+		{ "pagefault-conflict", MULTIGPU_CONFLICT | MULTIGPU_PFAULT_OP },
 		{ "concurrent-access-basic", MULTIGPU_CONC_ACCESS },
 		{ "concurrent-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_CONC_ACCESS },
+		{ "concurrent-access-conflict", MULTIGPU_CONFLICT | MULTIGPU_CONC_ACCESS },
 		{ NULL },
 	};
 
Signature · 1 line
2.48.1
Reviewed-by on v9 9/10
#21 lore raw

RE: [PATCH i-g-t v9 09/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU conflicting madvise test

Quoted 276 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 09/10] tests/intel/xe_multi_gpusvm: Add SVM multi-GPU conflicting madvise test

From: Nishit Sharma <[email protected]>

This test calls madvise operations on GPU0 with the preferred location set to GPU1 and vice versa. It reports conflicts when conflicting memory advice is given for shared SVM buffers in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 143
++++++++++++++++++++++++++++++++++
 1 file changed, 143 insertions(+)
tests/intel/xe_multi_gpusvm.c +27 -0
index bdbaa7a16..688ee0757 100644
@@ -110,6 +110,23 @@
  *	Test concurrent atomic memory operations with prefetch where
  *	multiple GPUs simultaneously access shared memory to validate
  *	coherency with memory migration and local VRAM access
+ *
+ * SUBTEST: mgpu-atomic-op-conflict
+ * Description:
+ *	Multi-GPU atomic operation with conflicting madvise regions
+ *
+ * SUBTEST: mgpu-coherency-conflict
+ * Description:
+ *	Multi-GPU coherency test with conflicting madvise regions
+ *
+ * SUBTEST: mgpu-concurrent-access-conflict
+ * Description:
+ *	Multi-GPU concurrent access with conflicting madvise regions
+ *
+ * SUBTEST: mgpu-pagefault-conflict
+ * Description:
+ *	Multi-GPU page fault test with conflicting madvise regions
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -123,6 +140,9 @@
 #define BATCH_VALUE	60
 #define NUM_ITER	200
 
+#define USER_FENCE_VALUE        0xdeadbeefdeadbeefull
+#define FIVE_SEC                (5LL * NSEC_PER_SEC)
+
 #define MULTIGPU_PREFETCH		BIT(1)
 #define MULTIGPU_XGPU_ACCESS		BIT(2)
 #define MULTIGPU_ATOMIC_OP		BIT(3)
@@ -132,6 +152,7 @@
 #define MULTIGPU_PERF_REM_COPY		BIT(7)
 #define MULTIGPU_PFAULT_OP		BIT(8)
 #define MULTIGPU_CONC_ACCESS		BIT(9)
+#define MULTIGPU_CONFLICT		BIT(10)
 
 #define INIT	2
 #define STORE	3
@@ -199,6 +220,12 @@ static void gpu_simult_test_wrapper(struct
 xe_svm_gpu_info *src,
 				    struct drm_xe_engine_class_instance *eci,
 				    unsigned int flags);
 
+static void
+conflicting_madvise(struct xe_svm_gpu_info *gpu1,
+		    struct xe_svm_gpu_info *gpu2,
+		    struct drm_xe_engine_class_instance *eci,
+		    unsigned int flags);
+
 static void
 create_vm_and_queue(struct xe_svm_gpu_info *gpu, struct

drm_xe_engine_class_instance *eci,
uint32_t *vm, uint32_t *exec_queue) @@ -616,6 +643,11
@@ atomic_inc_op(struct xe_svm_gpu_info *gpu1,

tests/intel/xe_multi_gpusvm.c +63 -0
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
@@ -697,6 +729,11 @@ coherency_test_multigpu(struct xe_svm_gpu_info
 *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
@@ -985,6 +1022,11 @@ pagefault_test_multigpu(struct xe_svm_gpu_info
 *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
@@ -1101,6 +1143,11 @@ multigpu_access_test(struct xe_svm_gpu_info
 *gpu1,
 	if (mgpu_check_fault_support(gpu1, gpu2))
 		return;
 
+	if (flags & MULTIGPU_CONFLICT) {
+		conflicting_madvise(gpu1, gpu2, eci, flags);
+		return;
+	}
+
 	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
 	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
@@ -1235,6 +1282,98 @@ multigpu_access_test(struct xe_svm_gpu_info
 *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);  }
 
+static void
+conflicting_madvise(struct xe_svm_gpu_info *gpu1,
+		    struct xe_svm_gpu_info *gpu2,
+		    struct drm_xe_engine_class_instance *eci,
+		    unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2];
+	uint32_t exec_queue[2];
+	uint32_t batch_bo[2];
+	void *data;
+	uint64_t batch_addr[2];
+	struct drm_xe_sync sync[2] = {};
+	uint64_t *sync_addr[2];
+
+	/* Skip if either GPU doesn't support faults */
+	if (!gpu1->supports_faults || !gpu2->supports_faults) {
+		igt_debug("Both GPUs must support page faults for this
 test\n");
+		return;
+	}
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	addr = to_user_pointer(data);
+
+	store_dword_batch_init(gpu1->fd, vm[0], addr, &batch_bo[0],
 &batch_addr[0], 10);
+	store_dword_batch_init(gpu2->fd, vm[1], addr, &batch_bo[1],
+&batch_addr[1], 20);
+
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM, 0, 0,
 exec_queue[0]);
+
+	igt_info("Testing GPU1 VM trying to prefer GPU2's VRAM (should
+fail)\n");
+
+	/* This SHOULD fail - GPU1's VM cannot prefer GPU2's VRAM */
+	xe_multigpu_madvise(gpu1->fd, vm[0], addr, SZ_4K,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu2->fd, 0, gpu2->vram_regions[0],

exec_queue[0]);

tests/intel/xe_multi_gpusvm.c +5 -0
+
+	/* This SHOULD also fail - GPU2's VM cannot prefer GPU1's VRAM */
+	xe_multigpu_madvise(gpu2->fd, vm[1], addr, SZ_4K,
+			    0, DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC,
+			    gpu1->fd, 0, gpu1->vram_regions[0],

exec_queue[0]);

tests/intel/xe_multi_gpusvm.c +5 -0
+
+	setup_sync(&sync[0], &sync_addr[0], BIND_SYNC_VAL);
+	setup_sync(&sync[1], &sync_addr[1], BIND_SYNC_VAL);
+
+	/* For simultaneous access need to call xe_wait_ufence for both

gpus after prefetch */

tests/intel/xe_multi_gpusvm.c +20 -0
+	xe_multigpu_prefetch(gpu1->fd, vm[0], addr, SZ_4K, &sync[0],
+			     sync_addr[0], exec_queue[0], flags);
+	free(sync_addr[0]);
+
+	xe_multigpu_prefetch(gpu2->fd, vm[1], addr, SZ_4K, &sync[1],
+			     sync_addr[1], exec_queue[1], flags);
+	free(sync_addr[1]);
+
+	for (int i = 0; i < NUM_ITER; i++) {
+		sync_addr[0] = (void *)((char *)batch_addr[0] + SZ_4K);
+		sync[0].addr = to_user_pointer((uint64_t *)sync_addr[0]);
+		sync[0].timeline_value = EXEC_SYNC_VAL;
+
+		sync_addr[1] = (void *)((char *)batch_addr[1] + SZ_4K);
+		sync[1].addr = to_user_pointer((uint64_t *)sync_addr[1]);
+		sync[1].timeline_value = EXEC_SYNC_VAL;
+		WRITE_ONCE(*sync_addr[0], 0);
+		WRITE_ONCE(*sync_addr[1], 0);
+
+		xe_exec_sync(gpu1->fd, exec_queue[0], batch_addr[0],

&sync[0], 1);

tests/intel/xe_multi_gpusvm.c +2 -0
+		if (READ_ONCE(*sync_addr[0]) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu1->fd, (uint64_t *)sync_addr[0],

EXEC_SYNC_VAL,

tests/intel/xe_multi_gpusvm.c +2 -0
+				       exec_queue[0], NSEC_PER_SEC * 10);
+		xe_exec_sync(gpu2->fd, exec_queue[1], batch_addr[1],

&sync[1], 1);

tests/intel/xe_multi_gpusvm.c +2 -0
+		if (READ_ONCE(*sync_addr[1]) != EXEC_SYNC_VAL)
+			xe_wait_ufence(gpu2->fd, (uint64_t *)sync_addr[1],

EXEC_SYNC_VAL,

tests/intel/xe_multi_gpusvm.c +15 -0
+				       exec_queue[1], NSEC_PER_SEC * 10);
+	}
+
+	igt_assert_eq(READ_ONCE(*(uint64_t *)addr), 20);
+
+	munmap((void *)batch_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch_bo[0], batch_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch_bo[1], batch_addr[1]);
+	free(data);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -1346,9 +1485,11 @@ igt_main
 		{ "xgpu-access-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_XGPU_ACCESS },
 		{ "atomic-op-basic", MULTIGPU_ATOMIC_OP },
 		{ "atomic-op-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_ATOMIC_OP },
+		{ "atomic-op-conflict", MULTIGPU_CONFLICT |
 MULTIGPU_ATOMIC_OP },
 		{ "coherency-basic", MULTIGPU_COH_OP },
 		{ "coherency-fail-basic", MULTIGPU_COH_OP |
 MULTIGPU_COH_FAIL },
 		{ "coherency-prefetch", MULTIGPU_PREFETCH |

MULTIGPU_COH_OP },

tests/intel/xe_multi_gpusvm.c +1 -0
+		{ "coherency-conflict", MULTIGPU_CONFLICT |

MULTIGPU_COH_OP },

tests/intel/xe_multi_gpusvm.c +0 -0
 		{ "coherency-fail-prefetch",
 		  MULTIGPU_PREFETCH | MULTIGPU_COH_OP |

MULTIGPU_COH_FAIL},

tests/intel/xe_multi_gpusvm.c +1 -0
 		{ "latency-basic", MULTIGPU_PERF_OP }, @@ -1359,8
+1500,10 @@ igt_main
 		  MULTIGPU_PREFETCH | MULTIGPU_PERF_OP |

MULTIGPU_PERF_REM_COPY },

tests/intel/xe_multi_gpusvm.c +0 -0
 		{ "pagefault-basic", MULTIGPU_PFAULT_OP },
 		{ "pagefault-prefetch", MULTIGPU_PREFETCH |

MULTIGPU_PFAULT_OP },

tests/intel/xe_multi_gpusvm.c +1 -0
+		{ "pagefault-conflict", MULTIGPU_CONFLICT |

MULTIGPU_PFAULT_OP },

tests/intel/xe_multi_gpusvm.c +0 -0
 		{ "concurrent-access-basic", MULTIGPU_CONC_ACCESS },
 		{ "concurrent-access-prefetch", MULTIGPU_PREFETCH |

MULTIGPU_CONC_ACCESS },

tests/intel/xe_multi_gpusvm.c igt_main · line 1508

Quoted 4 lines
tests/intel/xe_multi_gpusvm.c +2 -0
+		{ "concurrent-access-conflict", MULTIGPU_CONFLICT |
+MULTIGPU_CONC_ACCESS },
 		{ NULL },
 	};
Quoted 2 lines

--
2.48.1

#22 lore raw

PATCH v9 10/10 tests/intel/xe_multi-gpusvm: Add SVM multi-GPU migration test

In reply to [email protected]

From: Nishit Sharma <[email protected]>

This test allocates a buffer in SVM, accesses it from GPU 1, then GPU 2 and then the CPU. It verifies that the buffer migrates correctly between devices and remains accessible across all agents in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 122 ++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)
tests/intel/xe_multi_gpusvm.c +122 -0
index 688ee0757..d7d6ab116 100644
@@ -127,6 +127,18 @@
  * Description:
  *	Multi-GPU page fault test with conflicting madvise regions
  *
+ * SUBTEST: mgpu-migration-basic
+ * Description:
+ *	Test buffer migration across multiple GPUs and memory domains
+ *	Validates that a shared buffer can migrate between system memory,
+ *	GPU1 VRAM, and GPU2 VRAM while maintaining data coherency.
+ *
+ * SUBTEST: mgpu-migration-prefetch
+ * Description:
+ *	Test buffer migration across multiple GPUs with explicit prefetch operations
+ *	Similar to mgpu-migration-basic but uses XE_VM_PREFETCH_ASYNC to explicitly
+ *	trigger page migration before GPU access
+ *
  */
 
 #define MAX_XE_REGIONS	8
@@ -153,6 +165,7 @@
 #define MULTIGPU_PFAULT_OP		BIT(8)
 #define MULTIGPU_CONC_ACCESS		BIT(9)
 #define MULTIGPU_CONFLICT		BIT(10)
+#define MULTIGPU_MIGRATE		BIT(11)
 
 #define INIT	2
 #define STORE	3
@@ -220,6 +233,10 @@ static void gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
 				    struct drm_xe_engine_class_instance *eci,
 				    unsigned int flags);
 
+static void gpu_migration_test_wrapper(struct xe_svm_gpu_info *src,
+				       struct xe_svm_gpu_info *dst,
+				       struct drm_xe_engine_class_instance *eci,
+				       unsigned int flags);
 static void
 conflicting_madvise(struct xe_svm_gpu_info *gpu1,
 		    struct xe_svm_gpu_info *gpu2,
@@ -1374,6 +1391,95 @@ conflicting_madvise(struct xe_svm_gpu_info *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
 }
 
+static void
+multigpu_migrate_test(struct xe_svm_gpu_info *gpu1,
+		      struct xe_svm_gpu_info *gpu2,
+		      struct drm_xe_engine_class_instance *eci,
+		      unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2], exec_queue[2], batch1_bo[2];
+	uint64_t batch1_addr[2];
+	uint64_t *data;
+	uint32_t test_pattern_sys, test_pattern_gpu1, test_pattern_gpu2;
+	void *copy_dst;
+	uint32_t final_value;
+
+	test_pattern_sys = 0x12345678;
+	test_pattern_gpu1 = 0xDEADBEEF;
+	test_pattern_gpu2 = 0xCAFEBABE;
+
+	/* Skip if either GPU doesn't support faults */
+	if (!gpu1->supports_faults || !gpu2->supports_faults) {
+		igt_debug("Both GPUs must support page faults for this test\n");
+		return;
+	}
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	memset(data, 0, SZ_4K);
+	addr = to_user_pointer(data);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	igt_info("=== Phase 1: System Memory → GPU1 VRAM ===\n");
+
+	/* CPU writes initial pattern in system memory */
+	WRITE_ONCE(*(uint32_t *)data, test_pattern_sys);
+	igt_info("CPU wrote 0x%x to system memory\n", test_pattern_sys);
+
+	/* GPU1 writes new pattern - should happen in GPU1 VRAM */
+	store_dword_batch_init(gpu1->fd, vm[0], addr, &batch1_bo[0], &batch1_addr[0],
+			       test_pattern_gpu1);
+
+	/*GPU1: Madvise and Prefetch Ops with preferred location GPU1 VRAM */
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr, &batch1_addr[0], flags);
+
+	igt_info("=== Phase 2: GPU1 VRAM → GPU2 VRAM ===\n");
+
+	/* GPU2: copy GPU1's value */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr, to_user_pointer(copy_dst),
+			 &batch1_bo[1], &batch1_addr[1], flags, INIT);
+
+	/*GPU2: Madvise and Prefetch Ops with preferred location GPU2 VRAM */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+			 &batch1_addr[1], flags);
+
+	/* Verify GPU1 wrote correctly */
+	final_value = *(uint32_t *)copy_dst;
+	//igt_assert_eq_u32(READ_ONCE(*(uint32_t *)copy_dst), test_pattern_gpu1);
+	igt_assert_eq_u32(final_value, test_pattern_gpu1);
+
+	igt_info("=== Phase 3: GPU2 VRAM → System Memory ===\n");
+
+	/* GPU1 writes new pattern - should happen in GPU1 VRAM */
+	store_dword_batch_init(gpu2->fd, vm[1], to_user_pointer(copy_dst),
+			       &batch1_bo[1], &batch1_addr[1], test_pattern_gpu2);
+
+	/*GPU2: Madvise and Prefetch Ops with preferred location GPU2 VRAM */
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1], to_user_pointer(copy_dst),
+			 &batch1_addr[1], flags);
+
+	/* CPU access should migrate back to system memory */
+	igt_assert_eq_u32(READ_ONCE(*(uint32_t *)copy_dst), test_pattern_gpu2);
+
+	igt_info("Migration test completed successfully\n");
+
+	munmap((void *)batch1_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch1_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch1_bo[0], batch1_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch1_bo[1], batch1_addr[1]);
+	free(data);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);
+}
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -1446,6 +1552,18 @@ gpu_simult_test_wrapper(struct xe_svm_gpu_info *src,
 	multigpu_access_test(src, dst, eci, flags);
 }
 
+static void
+gpu_migration_test_wrapper(struct xe_svm_gpu_info *src,
+			   struct xe_svm_gpu_info *dst,
+			   struct drm_xe_engine_class_instance *eci,
+			   unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	multigpu_migrate_test(src, dst, eci, flags);
+}
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci,
@@ -1463,6 +1581,8 @@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_fault_test_wrapper, flags);
 	if (flags & MULTIGPU_CONC_ACCESS)
 		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_simult_test_wrapper, flags);
+	if (flags & MULTIGPU_MIGRATE)
+		for_each_gpu_pair(gpu_cnt, gpus, eci, gpu_migration_test_wrapper, flags);
 }
 
 struct section {
@@ -1504,6 +1624,8 @@ igt_main
 		{ "concurrent-access-basic", MULTIGPU_CONC_ACCESS },
 		{ "concurrent-access-prefetch", MULTIGPU_PREFETCH | MULTIGPU_CONC_ACCESS },
 		{ "concurrent-access-conflict", MULTIGPU_CONFLICT | MULTIGPU_CONC_ACCESS },
+		{ "migration-basic", MULTIGPU_MIGRATE },
+		{ "migration-prefetch", MULTIGPU_PREFETCH | MULTIGPU_MIGRATE },
 		{ NULL },
 	};
 
Signature · 1 line
2.48.1
Reviewed-by on v9 10/10
#23 lore raw

RE: [PATCH i-g-t v9 10/10] tests/intel/xe_multi-gpusvm: Add SVM multi-GPU migration test

Quoted 219 lines

-----Original Message-----
From: Sharma, Nishit <[email protected]>
Sent: Monday, December 1, 2025 2:34 PM
To: [email protected]; Sharma, Nishit <[email protected]>; Gurram, Pravalika <[email protected]>
Subject: [PATCH i-g-t v9 10/10] tests/intel/xe_multi-gpusvm: Add SVM multi- GPU migration test

From: Nishit Sharma <[email protected]>

This test allocates a buffer in SVM, accesses it from GPU 1, then GPU 2 and then the CPU. It verifies that the buffer migrates correctly between devices and remains accessible across all agents in a multi-GPU environment.

---
 tests/intel/xe_multi_gpusvm.c | 122
++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)
tests/intel/xe_multi_gpusvm.c +9 -0
index 688ee0757..d7d6ab116 100644
@@ -127,6 +127,18 @@
  * Description:
  *	Multi-GPU page fault test with conflicting madvise regions
  *
+ * SUBTEST: mgpu-migration-basic
+ * Description:
+ *	Test buffer migration across multiple GPUs and memory domains
+ *	Validates that a shared buffer can migrate between system memory,
+ *	GPU1 VRAM, and GPU2 VRAM while maintaining data coherency.
+ *
+ * SUBTEST: mgpu-migration-prefetch
+ * Description:
+ *	Test buffer migration across multiple GPUs with explicit prefetch

operations
+ * Similar to mgpu-migration-basic but uses XE_VM_PREFETCH_ASYNC
to explicitly
+ * trigger page migration before GPU access
+ *
*/

#define MAX_XE_REGIONS 8

tests/intel/xe_multi_gpusvm.c +5 -0
@@ -153,6 +165,7 @@
 #define MULTIGPU_PFAULT_OP		BIT(8)
 #define MULTIGPU_CONC_ACCESS		BIT(9)
 #define MULTIGPU_CONFLICT		BIT(10)
+#define MULTIGPU_MIGRATE		BIT(11)
 
 #define INIT	2
 #define STORE	3
@@ -220,6 +233,10 @@ static void gpu_simult_test_wrapper(struct
 xe_svm_gpu_info *src,
 				    struct drm_xe_engine_class_instance *eci,
 				    unsigned int flags);
 
+static void gpu_migration_test_wrapper(struct xe_svm_gpu_info *src,
+				       struct xe_svm_gpu_info *dst,
+				       struct drm_xe_engine_class_instance
 *eci,
+				       unsigned int flags);
 static void

conflicting_madvise(struct xe_svm_gpu_info *gpu1,

tests/intel/xe_multi_gpusvm.c +46 -0
 		    struct xe_svm_gpu_info *gpu2,
@@ -1374,6 +1391,95 @@ conflicting_madvise(struct xe_svm_gpu_info
 *gpu1,
 	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]);  }
 
+static void
+multigpu_migrate_test(struct xe_svm_gpu_info *gpu1,
+		      struct xe_svm_gpu_info *gpu2,
+		      struct drm_xe_engine_class_instance *eci,
+		      unsigned int flags)
+{
+	uint64_t addr;
+	uint32_t vm[2], exec_queue[2], batch1_bo[2];
+	uint64_t batch1_addr[2];
+	uint64_t *data;
+	uint32_t test_pattern_sys, test_pattern_gpu1, test_pattern_gpu2;
+	void *copy_dst;
+	uint32_t final_value;
+
+	test_pattern_sys = 0x12345678;
+	test_pattern_gpu1 = 0xDEADBEEF;
+	test_pattern_gpu2 = 0xCAFEBABE;
+
+	/* Skip if either GPU doesn't support faults */
+	if (!gpu1->supports_faults || !gpu2->supports_faults) {
+		igt_debug("Both GPUs must support page faults for this
 test\n");
+		return;
+	}
+
+	create_vm_and_queue(gpu1, eci, &vm[0], &exec_queue[0]);
+	create_vm_and_queue(gpu2, eci, &vm[1], &exec_queue[1]);
+
+	data = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(data);
+	memset(data, 0, SZ_4K);
+	addr = to_user_pointer(data);
+
+	copy_dst = aligned_alloc(SZ_2M, SZ_4K);
+	igt_assert(copy_dst);
+
+	igt_info("=== Phase 1: System Memory → GPU1 VRAM ===\n");
+
+	/* CPU writes initial pattern in system memory */
+	WRITE_ONCE(*(uint32_t *)data, test_pattern_sys);
+	igt_info("CPU wrote 0x%x to system memory\n", test_pattern_sys);
+
+	/* GPU1 writes new pattern - should happen in GPU1 VRAM */
+	store_dword_batch_init(gpu1->fd, vm[0], addr, &batch1_bo[0],
 &batch1_addr[0],
+			       test_pattern_gpu1);
+
+	/*GPU1: Madvise and Prefetch Ops with preferred location GPU1

VRAM */

tests/intel/xe_multi_gpusvm.c +1 -0
+	gpu_madvise_sync(gpu1, vm[0], exec_queue[0], addr,

&batch1_addr[0],

tests/intel/xe_multi_gpusvm.c +6 -0
+flags);
+
+	igt_info("=== Phase 2: GPU1 VRAM → GPU2 VRAM ===\n");
+
+	/* GPU2: copy GPU1's value */
+	gpu_batch_create(gpu2, vm[1], exec_queue[1], addr,

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +3 -0
+			 &batch1_bo[1], &batch1_addr[1], flags, INIT);
+
+	/*GPU2: Madvise and Prefetch Ops with preferred location GPU2

VRAM */

tests/intel/xe_multi_gpusvm.c +1 -0
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1],

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +5 -0
+			 &batch1_addr[1], flags);
+
+	/* Verify GPU1 wrote correctly */
+	final_value = *(uint32_t *)copy_dst;
+	//igt_assert_eq_u32(READ_ONCE(*(uint32_t *)copy_dst),

test_pattern_gpu1);

tests/intel/xe_multi_gpusvm.c +6 -0
+	igt_assert_eq_u32(final_value, test_pattern_gpu1);
+
+	igt_info("=== Phase 3: GPU2 VRAM → System Memory ===\n");
+
+	/* GPU1 writes new pattern - should happen in GPU1 VRAM */
+	store_dword_batch_init(gpu2->fd, vm[1],

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +1 -0
+			       &batch1_bo[1], &batch1_addr[1],

test_pattern_gpu2);

tests/intel/xe_multi_gpusvm.c +2 -0
+
+	/*GPU2: Madvise and Prefetch Ops with preferred location GPU2

VRAM */

tests/intel/xe_multi_gpusvm.c +1 -0
+	gpu_madvise_sync(gpu2, vm[1], exec_queue[1],

to_user_pointer(copy_dst),

tests/intel/xe_multi_gpusvm.c +29 -0
+			 &batch1_addr[1], flags);
+
+	/* CPU access should migrate back to system memory */
+	igt_assert_eq_u32(READ_ONCE(*(uint32_t *)copy_dst),
+test_pattern_gpu2);
+
+	igt_info("Migration test completed successfully\n");
+
+	munmap((void *)batch1_addr[0], BATCH_SIZE(gpu1->fd));
+	munmap((void *)batch1_addr[1], BATCH_SIZE(gpu2->fd));
+	batch_fini(gpu1->fd, vm[0], batch1_bo[0], batch1_addr[0]);
+	batch_fini(gpu2->fd, vm[1], batch1_bo[1], batch1_addr[1]);
+	free(data);
+	free(copy_dst);
+
+	cleanup_vm_and_queue(gpu1, vm[0], exec_queue[0]);
+	cleanup_vm_and_queue(gpu2, vm[1], exec_queue[1]); }
+
 static void
 gpu_mem_access_wrapper(struct xe_svm_gpu_info *src,
 		       struct xe_svm_gpu_info *dst,
@@ -1446,6 +1552,18 @@ gpu_simult_test_wrapper(struct
 xe_svm_gpu_info *src,
 	multigpu_access_test(src, dst, eci, flags);  }
 
+static void
+gpu_migration_test_wrapper(struct xe_svm_gpu_info *src,
+			   struct xe_svm_gpu_info *dst,
+			   struct drm_xe_engine_class_instance *eci,
+			   unsigned int flags)
+{
+	igt_assert(src);
+	igt_assert(dst);
+
+	multigpu_migrate_test(src, dst, eci, flags); }
+
 static void
 test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
 	       struct drm_xe_engine_class_instance *eci, @@ -1463,6 +1581,8

@@ test_mgpu_exec(int gpu_cnt, struct xe_svm_gpu_info *gpus,
for_each_gpu_pair(gpu_cnt, gpus, eci,
gpu_fault_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +0 -0
 	if (flags & MULTIGPU_CONC_ACCESS)
 		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_simult_test_wrapper, flags);

tests/intel/xe_multi_gpusvm.c +2 -0
+	if (flags & MULTIGPU_MIGRATE)
+		for_each_gpu_pair(gpu_cnt, gpus, eci,

gpu_migration_test_wrapper,

tests/intel/xe_multi_gpusvm.c +3 -0
+flags);
 }
 
 struct section {
@@ -1504,6 +1624,8 @@ igt_main
 		{ "concurrent-access-basic", MULTIGPU_CONC_ACCESS },
 		{ "concurrent-access-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_CONC_ACCESS },
 		{ "concurrent-access-conflict", MULTIGPU_CONFLICT |
 MULTIGPU_CONC_ACCESS },
+		{ "migration-basic", MULTIGPU_MIGRATE },
+		{ "migration-prefetch", MULTIGPU_PREFETCH |
 MULTIGPU_MIGRATE },

tests/intel/xe_multi_gpusvm.c igt_main · line 1630

Quoted 2 lines
tests/intel/xe_multi_gpusvm.c +0 -0
 		{ NULL },
 	};
Quoted 2 lines

--
2.48.1

#24 lore raw

✗ i915.CI.BAT: failure for Madvise feature in SVM for Multi-GPU configs

In reply to [email protected]
== Series Details ==

== Series Details ==

Series: Madvise feature in SVM for Multi-GPU configs
URL : https://patchwork.freedesktop.org/series/158273/
State : failure

== Summary ==

CI Bug Log - changes from IGT_8645 -> IGTPW_14134
====================================================

Summary
-------

**FAILURE**

Serious unknown changes coming with IGTPW_14134 absolutely need to be verified manually.

If you think the reported changes have nothing to do with the changes
introduced in IGTPW_14134, please notify your bug team ([email protected]) to allow them to document this new failure mode, which will reduce false positives in CI.

External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/index.html

Participating hosts (45 -> 43)
------------------------------

Missing (2): bat-atsm-1 fi-snb-2520m

Possible new issues
-------------------

Here are the unknown changes that may have been introduced in IGTPW_14134:

### IGT changes ###

#### Possible regressions ####

* igt@vgem_basic@second-client:
- fi-kbl-guc: [PASS][1] -> [INCOMPLETE][2]
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/fi-kbl-guc/igt@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/fi-kbl-guc/igt@[email protected]

Known issues
------------

Here are the changes found in IGTPW_14134 that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@i915_selftest@live:
- bat-arlh-3: [PASS][3] -> [INCOMPLETE][4] ([i915#14818] / [i915#14837])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-arlh-3/igt@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-arlh-3/igt@[email protected]

* igt@i915_selftest@live@sanitycheck:
- bat-apl-1: [PASS][5] -> [DMESG-WARN][6] ([i915#13735]) +77 other tests dmesg-warn
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-apl-1/igt@i915_selftest@[email protected]
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-apl-1/igt@i915_selftest@[email protected]
- bat-arlh-3: [PASS][7] -> [INCOMPLETE][8] ([i915#15303])
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-arlh-3/igt@i915_selftest@[email protected]
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-arlh-3/igt@i915_selftest@[email protected]

* igt@i915_selftest@live@workarounds:
- bat-arls-5: [PASS][9] -> [DMESG-FAIL][10] ([i915#12061]) +1 other test dmesg-fail
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-arls-5/igt@i915_selftest@[email protected]
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-arls-5/igt@i915_selftest@[email protected]

* igt@kms_pm_rpm@basic-pci-d3-state:
- bat-apl-1: [PASS][11] -> [DMESG-WARN][12] ([i915#13735] / [i915#180]) +49 other tests dmesg-warn
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-apl-1/igt@[email protected]
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-apl-1/igt@[email protected]

#### Possible fixes ####

* igt@i915_selftest@live:
- bat-arlh-2: [INCOMPLETE][13] ([i915#14837]) -> [PASS][14]
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-arlh-2/igt@[email protected]
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-arlh-2/igt@[email protected]
- bat-mtlp-9: [INCOMPLETE][15] ([i915#15176]) -> [PASS][16]
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-mtlp-9/igt@[email protected]
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-mtlp-9/igt@[email protected]

* igt@i915_selftest@live@perf:
- bat-arlh-2: [INCOMPLETE][17] ([i915#15348]) -> [PASS][18]
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-arlh-2/igt@i915_selftest@[email protected]
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-arlh-2/igt@i915_selftest@[email protected]

* igt@i915_selftest@live@workarounds:
- bat-dg2-9: [DMESG-FAIL][19] ([i915#12061]) -> [PASS][20] +1 other test pass
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-dg2-9/igt@i915_selftest@[email protected]
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-dg2-9/igt@i915_selftest@[email protected]
- bat-mtlp-9: [INCOMPLETE][21] ([i915#15349]) -> [PASS][22]
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-mtlp-9/igt@i915_selftest@[email protected]
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-mtlp-9/igt@i915_selftest@[email protected]
- bat-arls-6: [DMESG-FAIL][23] ([i915#12061]) -> [PASS][24] +1 other test pass
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8645/bat-arls-6/igt@i915_selftest@[email protected]
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/bat-arls-6/igt@i915_selftest@[email protected]

[i915#12061]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12061
[i915#13735]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13735
[i915#14818]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14818
[i915#14837]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14837
[i915#15176]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15176
[i915#15303]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15303
[i915#15348]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15348
[i915#15349]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15349
[i915#180]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/180

Build changes
-------------

* CI: CI-20190529 -> None
* IGT: IGT_8645 -> IGTPW_14134
* Linux: CI_DRM_17605 -> CI_DRM_17612

CI-20190529: 20190529
CI_DRM_17605: e1c1b3e03e356d1e20432dcb0d38ad44d5e92670 @ git://anongit.freedesktop.org/gfx-ci/linux
CI_DRM_17612: 7f7b6cfa09ab1155b3e92ccfb7ae4bbfd41fec0c @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_14134: b65fda72613cfe245a286902212314d01e6cfdd5 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8645: 8645

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14134/index.html

#25 lore raw

✓ Xe.CI.BAT: success for Madvise feature in SVM for Multi-GPU configs

In reply to [email protected]
== Series Details ==

== Series Details ==

Series: Madvise feature in SVM for Multi-GPU configs
URL : https://patchwork.freedesktop.org/series/158273/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_8645_BAT -> XEIGTPW_14134_BAT
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (11 -> 12)
------------------------------

Additional (1): bat-dg2-oem2

Known issues
------------

Here are the changes found in XEIGTPW_14134_BAT that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@kms_addfb_basic@addfb25-y-tiled-small-legacy:
- bat-dg2-oem2: NOTRUN -> [SKIP][1] ([Intel XE#623])
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@kms_dsc@dsc-basic:
- bat-dg2-oem2: NOTRUN -> [SKIP][2] ([Intel XE#455])
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@kms_psr@psr-cursor-plane-move:
- bat-dg2-oem2: NOTRUN -> [SKIP][3] ([Intel XE#1406] / [Intel XE#2850] / [Intel XE#929]) +2 other tests skip
[3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@sriov_basic@enable-vfs-autoprobe-off:
- bat-dg2-oem2: NOTRUN -> [SKIP][4] ([Intel XE#1091] / [Intel XE#2849]) +1 other test skip
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_exec_fault_mode@twice-bindexecqueue-userptr:
- bat-dg2-oem2: NOTRUN -> [SKIP][5] ([Intel XE#288]) +32 other tests skip
[5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_huc_copy@huc_copy:
- bat-dg2-oem2: NOTRUN -> [SKIP][6] ([Intel XE#255])
[6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@xe_huc_copy@huc_copy.html

* igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit:
- bat-dg2-oem2: NOTRUN -> [SKIP][7] ([Intel XE#2229])
[7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit.html

* igt@xe_pat@pat-index-xe2:
- bat-dg2-oem2: NOTRUN -> [SKIP][8] ([Intel XE#977])
[8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_pat@pat-index-xehpc:
- bat-dg2-oem2: NOTRUN -> [SKIP][9] ([Intel XE#2838] / [Intel XE#979])
[9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_pat@pat-index-xelpg:
- bat-dg2-oem2: NOTRUN -> [SKIP][10] ([Intel XE#979])
[10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_sriov_flr@flr-vf1-clear:
- bat-dg2-oem2: NOTRUN -> [SKIP][11] ([Intel XE#3342])
[11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_waitfence@abstime:
- bat-dg2-oem2: NOTRUN -> [TIMEOUT][12] ([Intel XE#6506])
[12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

* igt@xe_waitfence@engine:
- bat-dg2-oem2: NOTRUN -> [FAIL][13] ([Intel XE#6519])
[13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/bat-dg2-oem2/igt@[email protected]

[Intel XE#1091]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1091
[Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406
[Intel XE#2229]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2229
[Intel XE#255]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/255
[Intel XE#2838]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2838
[Intel XE#2849]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2849
[Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
[Intel XE#288]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/288
[Intel XE#3342]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3342
[Intel XE#455]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/455
[Intel XE#623]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/623
[Intel XE#6506]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6506
[Intel XE#6519]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6519
[Intel XE#929]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/929
[Intel XE#977]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/977
[Intel XE#979]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/979

Build changes
-------------

* IGT: IGT_8645 -> IGTPW_14134
* Linux: xe-4166-e1c1b3e03e356d1e20432dcb0d38ad44d5e92670 -> xe-4172-97dd55b95199516099b8b5871ba2bd3450a3dd83

IGTPW_14134: b65fda72613cfe245a286902212314d01e6cfdd5 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8645: 8645
xe-4166-e1c1b3e03e356d1e20432dcb0d38ad44d5e92670: e1c1b3e03e356d1e20432dcb0d38ad44d5e92670 xe-4172-97dd55b95199516099b8b5871ba2bd3450a3dd83: 97dd55b95199516099b8b5871ba2bd3450a3dd83

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/index.html

#26 lore raw

✓ Xe.CI.Full: success for Madvise feature in SVM for Multi-GPU configs

In reply to [email protected]
== Series Details ==

== Series Details ==

Series: Madvise feature in SVM for Multi-GPU configs
URL : https://patchwork.freedesktop.org/series/158273/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_8645_FULL -> XEIGTPW_14134_FULL
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (4 -> 3)
------------------------------

Missing (1): shard-adlp

Possible new issues
-------------------

Here are the unknown changes that may have been introduced in XEIGTPW_14134_FULL:

### IGT changes ###

#### Possible regressions ####

* {igt@xe_multi_gpusvm@mgpu-coherency-fail-prefetch} (NEW):
- shard-bmg: NOTRUN -> [SKIP][1] +13 other tests skip
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]

* {igt@xe_multi_gpusvm@mgpu-latency-copy-basic} (NEW):
- shard-lnl: NOTRUN -> [SKIP][2] +10 other tests skip
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

New tests
---------

New tests have been introduced between XEIGT_8645_FULL and XEIGTPW_14134_FULL:

### New IGT tests (28) ###

* igt@kms_cursor_crc@cursor-sliding-128x128@pipe-a-dp-2:
- Statuses : 1 pass(s)
- Exec time: [4.61] s

* igt@kms_cursor_crc@cursor-sliding-128x128@pipe-d-dp-2:
- Statuses : 1 pass(s)
- Exec time: [4.38] s

* igt@kms_plane_alpha_blend@alpha-opaque-fb@pipe-a-dp-2:
- Statuses : 1 pass(s)
- Exec time: [0.53] s

* igt@kms_plane_alpha_blend@alpha-opaque-fb@pipe-d-dp-2:
- Statuses : 1 pass(s)
- Exec time: [0.56] s

* igt@kms_plane_alpha_blend@alpha-transparent-fb@pipe-a-dp-2:
- Statuses : 1 pass(s)
- Exec time: [0.56] s

* igt@kms_plane_alpha_blend@alpha-transparent-fb@pipe-d-dp-2:
- Statuses : 1 pass(s)
- Exec time: [0.54] s

* igt@xe_multi_gpusvm@mgpu-atomic-op-basic:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-atomic-op-conflict:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-atomic-op-prefetch:
- Statuses :
- Exec time: [None] s

* igt@xe_multi_gpusvm@mgpu-coherency-basic:
- Statuses : 1 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-coherency-conflict:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-coherency-fail-basic:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-coherency-fail-prefetch:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-coherency-prefetch:
- Statuses :
- Exec time: [None] s

* igt@xe_multi_gpusvm@mgpu-concurrent-access-basic:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-concurrent-access-conflict:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-concurrent-access-prefetch:
- Statuses :
- Exec time: [None] s

* igt@xe_multi_gpusvm@mgpu-latency-basic:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-latency-copy-basic:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-latency-copy-prefetch:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-latency-prefetch:
- Statuses :
- Exec time: [None] s

* igt@xe_multi_gpusvm@mgpu-migration-basic:
- Statuses :
- Exec time: [None] s

* igt@xe_multi_gpusvm@mgpu-migration-prefetch:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-pagefault-basic:
- Statuses : 1 pass(s) 2 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-pagefault-conflict:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-pagefault-prefetch:
- Statuses :
- Exec time: [None] s

* igt@xe_multi_gpusvm@mgpu-xgpu-access-basic:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0] s

* igt@xe_multi_gpusvm@mgpu-xgpu-access-prefetch:
- Statuses :
- Exec time: [None] s

Known issues
------------

Here are the changes found in XEIGTPW_14134_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@kms_async_flips@async-flip-with-page-flip-events-tiled-atomic@pipe-a-edp-1-x:
- shard-lnl: NOTRUN -> [FAIL][3] ([Intel XE#6676]) +12 other tests fail
[3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@kms_async_flips@async-flip-with-page-flip-events-tiled-atomic@pipe-a-edp-1-x.html

* igt@kms_big_fb@4-tiled-16bpp-rotate-270:
- shard-lnl: NOTRUN -> [SKIP][4] ([Intel XE#1407]) +5 other tests skip
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]

* igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip:
- shard-lnl: NOTRUN -> [SKIP][5] ([Intel XE#3658]) +1 other test skip
[5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip.html

* igt@kms_big_fb@linear-16bpp-rotate-270:
- shard-dg2-set2: NOTRUN -> [SKIP][6] ([Intel XE#316]) +3 other tests skip
[6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@kms_big_fb@x-tiled-32bpp-rotate-90:
- shard-bmg: NOTRUN -> [SKIP][7] ([Intel XE#2327]) +4 other tests skip
[7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_big_fb@y-tiled-32bpp-rotate-0:
- shard-lnl: NOTRUN -> [SKIP][8] ([Intel XE#1124]) +16 other tests skip
[8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@kms_big_fb@y-tiled-addfb-size-overflow:
- shard-bmg: NOTRUN -> [SKIP][9] ([Intel XE#610]) +1 other test skip
[9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][10] ([Intel XE#610]) +1 other test skip
[10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-0-hflip:
- shard-dg2-set2: NOTRUN -> [SKIP][11] ([Intel XE#1124]) +21 other tests skip
[11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]

* igt@kms_big_fb@yf-tiled-32bpp-rotate-0:
- shard-bmg: NOTRUN -> [SKIP][12] ([Intel XE#1124]) +23 other tests skip
[12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow:
- shard-bmg: NOTRUN -> [SKIP][13] ([Intel XE#607])
[13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][14] ([Intel XE#607])
[14]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][15] ([Intel XE#1477])
[15]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_big_fb@yf-tiled-addfb-size-overflow:
- shard-lnl: NOTRUN -> [SKIP][16] ([Intel XE#1428])
[16]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@kms_bw@connected-linear-tiling-4-displays-1920x1080p:
- shard-dg2-set2: NOTRUN -> [SKIP][17] ([Intel XE#2191]) +2 other tests skip
[17]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]

* igt@kms_bw@connected-linear-tiling-4-displays-2560x1440p:
- shard-lnl: NOTRUN -> [SKIP][18] ([Intel XE#1512]) +1 other test skip
[18]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_bw@connected-linear-tiling-4-displays-3840x2160p:
- shard-bmg: NOTRUN -> [SKIP][19] ([Intel XE#2314] / [Intel XE#2894]) +1 other test skip
[19]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@kms_bw@linear-tiling-2-displays-3840x2160p:
- shard-dg2-set2: NOTRUN -> [SKIP][20] ([Intel XE#367]) +2 other tests skip
[20]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][21] ([Intel XE#367]) +1 other test skip
[21]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@kms_bw@linear-tiling-4-displays-2160x1440p:
- shard-bmg: NOTRUN -> [SKIP][22] ([Intel XE#367]) +3 other tests skip
[22]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@kms_ccs@bad-pixel-format-4-tiled-mtl-rc-ccs-cc@pipe-a-hdmi-a-6:
- shard-dg2-set2: NOTRUN -> [SKIP][23] ([Intel XE#787]) +111 other tests skip
[23]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@kms_ccs@[email protected]

* igt@kms_ccs@bad-pixel-format-yf-tiled-ccs:
- shard-lnl: NOTRUN -> [SKIP][24] ([Intel XE#2887]) +22 other tests skip
[24]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@kms_ccs@bad-rotation-90-4-tiled-bmg-ccs:
- shard-dg2-set2: NOTRUN -> [SKIP][25] ([Intel XE#2907]) +3 other tests skip
[25]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@kms_ccs@bad-rotation-90-4-tiled-bmg-ccs@pipe-a-edp-1:
- shard-lnl: NOTRUN -> [SKIP][26] ([Intel XE#2669]) +11 other tests skip
[26]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@kms_ccs@[email protected]

* igt@kms_ccs@bad-rotation-90-4-tiled-lnl-ccs@pipe-c-dp-2:
- shard-bmg: NOTRUN -> [SKIP][27] ([Intel XE#2652] / [Intel XE#787]) +8 other tests skip
[27]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@kms_ccs@[email protected]

* igt@kms_ccs@crc-primary-suspend-4-tiled-mtl-rc-ccs-cc:
- shard-lnl: NOTRUN -> [SKIP][28] ([Intel XE#3432]) +2 other tests skip
[28]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@kms_ccs@crc-primary-suspend-yf-tiled-ccs:
- shard-bmg: NOTRUN -> [SKIP][29] ([Intel XE#3432]) +2 other tests skip
[29]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@kms_ccs@crc-sprite-planes-basic-4-tiled-dg2-rc-ccs-cc:
- shard-bmg: NOTRUN -> [SKIP][30] ([Intel XE#2887]) +21 other tests skip
[30]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_ccs@missing-ccs-buffer-4-tiled-mtl-mc-ccs@pipe-d-dp-4:
- shard-dg2-set2: NOTRUN -> [SKIP][31] ([Intel XE#455] / [Intel XE#787]) +31 other tests skip
[31]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@kms_ccs@[email protected]

* igt@kms_ccs@random-ccs-data-4-tiled-dg2-mc-ccs:
- shard-dg2-set2: NOTRUN -> [INCOMPLETE][32] ([Intel XE#2705] / [Intel XE#4212] / [Intel XE#4345])
[32]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-466/igt@[email protected]

* igt@kms_ccs@random-ccs-data-4-tiled-dg2-mc-ccs@pipe-a-dp-4:
- shard-dg2-set2: NOTRUN -> [INCOMPLETE][33] ([Intel XE#2705] / [Intel XE#4212] / [Intel XE#6014])
[33]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-466/igt@kms_ccs@[email protected]

* igt@kms_cdclk@mode-transition-all-outputs:
- shard-bmg: NOTRUN -> [SKIP][34] ([Intel XE#2724])
[34]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][35] ([Intel XE#4418])
[35]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]

* igt@kms_cdclk@mode-transition@pipe-b-edp-1:
- shard-lnl: NOTRUN -> [SKIP][36] ([Intel XE#4417]) +3 other tests skip
[36]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_cdclk@[email protected]

* igt@kms_cdclk@plane-scaling:
- shard-lnl: NOTRUN -> [SKIP][37] ([Intel XE#4416]) +3 other tests skip
[37]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_chamelium_color@ctm-0-75:
- shard-dg2-set2: NOTRUN -> [SKIP][38] ([Intel XE#306]) +3 other tests skip
[38]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@kms_chamelium_color@ctm-max:
- shard-lnl: NOTRUN -> [SKIP][39] ([Intel XE#306]) +1 other test skip
[39]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@kms_chamelium_color@degamma:
- shard-bmg: NOTRUN -> [SKIP][40] ([Intel XE#2325]) +4 other tests skip
[40]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_chamelium_frames@hdmi-crc-nonplanar-formats:
- shard-dg2-set2: NOTRUN -> [SKIP][41] ([Intel XE#373]) +16 other tests skip
[41]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]

* igt@kms_chamelium_hpd@common-hpd-after-suspend:
- shard-bmg: NOTRUN -> [SKIP][42] ([Intel XE#2252]) +16 other tests skip
[42]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@[email protected]

* igt@kms_chamelium_hpd@vga-hpd-enable-disable-mode:
- shard-lnl: NOTRUN -> [SKIP][43] ([Intel XE#373]) +12 other tests skip
[43]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@kms_colorop@plane-xr24-xr24-pq_eotf-pq_inv_eotf:
- shard-bmg: NOTRUN -> [SKIP][44] ([Intel XE#6704]) +12 other tests skip
[44]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@kms_colorop@plane-xr24-xr24-pq_eotf-pq_inv_eotf.html
- shard-dg2-set2: NOTRUN -> [SKIP][45] ([Intel XE#6704]) +11 other tests skip
[45]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@kms_colorop@plane-xr24-xr24-pq_eotf-pq_inv_eotf.html

* igt@kms_colorop@plane-xr30-xr30-srgb_eotf:
- shard-lnl: NOTRUN -> [SKIP][46] ([Intel XE#6704]) +12 other tests skip
[46]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@kms_colorop@plane-xr30-xr30-srgb_eotf.html

* igt@kms_content_protection@atomic-dpms@pipe-a-dp-2:
- shard-bmg: NOTRUN -> [FAIL][47] ([Intel XE#1178]) +1 other test fail
[47]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@kms_content_protection@[email protected]

* igt@kms_content_protection@dp-mst-lic-type-0:
- shard-dg2-set2: NOTRUN -> [SKIP][48] ([Intel XE#307])
[48]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][49] ([Intel XE#307])
[49]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]
- shard-bmg: NOTRUN -> [SKIP][50] ([Intel XE#2390])
[50]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@kms_content_protection@lic-type-1:
- shard-lnl: NOTRUN -> [SKIP][51] ([Intel XE#3278]) +2 other tests skip
[51]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_content_protection@srm:
- shard-bmg: NOTRUN -> [SKIP][52] ([Intel XE#2341]) +1 other test skip
[52]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_content_protection@srm@pipe-a-dp-4:
- shard-dg2-set2: NOTRUN -> [FAIL][53] ([Intel XE#1178]) +3 other tests fail
[53]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@kms_content_protection@[email protected]

* igt@kms_cursor_crc@cursor-random-512x170:
- shard-bmg: NOTRUN -> [SKIP][54] ([Intel XE#2321]) +3 other tests skip
[54]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_cursor_crc@cursor-rapid-movement-32x10:
- shard-bmg: NOTRUN -> [SKIP][55] ([Intel XE#2320]) +8 other tests skip
[55]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]

* igt@kms_cursor_crc@cursor-rapid-movement-512x170:
- shard-dg2-set2: NOTRUN -> [SKIP][56] ([Intel XE#308]) +2 other tests skip
[56]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]

* igt@kms_cursor_crc@cursor-rapid-movement-512x512:
- shard-lnl: NOTRUN -> [SKIP][57] ([Intel XE#2321]) +2 other tests skip
[57]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]

* igt@kms_cursor_crc@cursor-rapid-movement-64x21:
- shard-lnl: NOTRUN -> [SKIP][58] ([Intel XE#1424]) +6 other tests skip
[58]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]

* igt@kms_cursor_crc@cursor-suspend:
- shard-bmg: NOTRUN -> [ABORT][59] ([Intel XE#6675]) +19 other tests abort
[59]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@kms_cursor_legacy@2x-long-cursor-vs-flip-atomic:
- shard-bmg: NOTRUN -> [SKIP][60] ([Intel XE#2291])
[60]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_cursor_legacy@2x-nonblocking-modeset-vs-cursor-atomic:
- shard-lnl: NOTRUN -> [SKIP][61] ([Intel XE#309]) +3 other tests skip
[61]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions:
- shard-bmg: [PASS][62] -> [SKIP][63] ([Intel XE#2291])
[62]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-3/igt@[email protected]
[63]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions:
- shard-bmg: NOTRUN -> [FAIL][64] ([Intel XE#5299])
[64]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size:
- shard-lnl: NOTRUN -> [SKIP][65] ([Intel XE#323]) +1 other test skip
[65]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size.html

* igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle:
- shard-dg2-set2: NOTRUN -> [SKIP][66] ([Intel XE#323]) +1 other test skip
[66]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]
- shard-bmg: NOTRUN -> [SKIP][67] ([Intel XE#2286])
[67]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_dp_linktrain_fallback@dsc-fallback:
- shard-bmg: NOTRUN -> [SKIP][68] ([Intel XE#4331])
[68]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_dsc@dsc-fractional-bpp-with-bpc:
- shard-bmg: NOTRUN -> [SKIP][69] ([Intel XE#2244]) +3 other tests skip
[69]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@kms_dsc@dsc-with-output-formats-with-bpc:
- shard-lnl: NOTRUN -> [SKIP][70] ([Intel XE#2244]) +3 other tests skip
[70]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@kms_fbcon_fbt@fbc-suspend:
- shard-bmg: NOTRUN -> [SKIP][71] ([Intel XE#4156])
[71]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]

* igt@kms_feature_discovery@display-4x:
- shard-bmg: NOTRUN -> [SKIP][72] ([Intel XE#1138])
[72]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][73] ([Intel XE#1138])
[73]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-466/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][74] ([Intel XE#1138])
[74]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@kms_flip@2x-flip-vs-dpms-off-vs-modeset:
- shard-bmg: NOTRUN -> [SKIP][75] ([Intel XE#2316]) +3 other tests skip
[75]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_flip@2x-flip-vs-expired-vblank:
- shard-lnl: NOTRUN -> [SKIP][76] ([Intel XE#1421]) +12 other tests skip
[76]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]

* igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-default-mode:
- shard-lnl: NOTRUN -> [SKIP][77] ([Intel XE#1401]) +8 other tests skip
[77]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling:
- shard-lnl: NOTRUN -> [SKIP][78] ([Intel XE#1401] / [Intel XE#1745]) +8 other tests skip
[78]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling.html

* igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-downscaling:
- shard-lnl: NOTRUN -> [SKIP][79] ([Intel XE#1397] / [Intel XE#1745]) +1 other test skip
[79]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-downscaling.html

* igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-downscaling@pipe-a-default-mode:
- shard-lnl: NOTRUN -> [SKIP][80] ([Intel XE#1397]) +1 other test skip
[80]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-downscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling:
- shard-bmg: NOTRUN -> [SKIP][81] ([Intel XE#2380]) +1 other test skip
[81]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html

* igt@kms_flip_scaled_crc@flip-64bpp-xtile-to-16bpp-xtile-upscaling@pipe-a-default-mode:
- shard-lnl: NOTRUN -> [FAIL][82] ([Intel XE#3106] / [Intel XE#4683]) +1 other test fail
[82]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_flip_scaled_crc@flip-64bpp-xtile-to-16bpp-xtile-upscaling@pipe-a-default-mode.html

* igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-downscaling:
- shard-bmg: NOTRUN -> [SKIP][83] ([Intel XE#2293] / [Intel XE#2380]) +7 other tests skip
[83]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-downscaling.html

* igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilercccs-downscaling@pipe-a-valid-mode:
- shard-bmg: NOTRUN -> [SKIP][84] ([Intel XE#2293]) +7 other tests skip
[84]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytilercccs-downscaling@pipe-a-valid-mode.html

* igt@kms_force_connector_basic@prune-stale-modes:
- shard-lnl: NOTRUN -> [SKIP][85] ([Intel XE#352]) +1 other test skip
[85]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]

* igt@kms_frontbuffer_tracking@drrs-rgb565-draw-render:
- shard-bmg: NOTRUN -> [SKIP][86] ([Intel XE#2311]) +37 other tests skip
[86]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt:
- shard-bmg: NOTRUN -> [SKIP][87] ([Intel XE#4141]) +21 other tests skip
[87]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-blt:
- shard-lnl: NOTRUN -> [SKIP][88] ([Intel XE#656]) +53 other tests skip
[88]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcdrrs-1p-offscreen-pri-indfb-draw-blt:
- shard-lnl: NOTRUN -> [SKIP][89] ([Intel XE#6312]) +4 other tests skip
[89]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@kms_frontbuffer_tracking@fbcdrrs-1p-offscreen-pri-indfb-draw-blt.html

* igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-indfb-msflip-blt:
- shard-lnl: NOTRUN -> [SKIP][90] ([Intel XE#651]) +19 other tests skip
[90]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-indfb-msflip-blt.html

* igt@kms_frontbuffer_tracking@fbcdrrs-rgb101010-draw-mmap-wc:
- shard-dg2-set2: NOTRUN -> [SKIP][91] ([Intel XE#651]) +33 other tests skip
[91]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-indfb-draw-render:
- shard-bmg: NOTRUN -> [SKIP][92] ([Intel XE#2312]) +16 other tests skip
[92]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-indfb-draw-render.html

* igt@kms_frontbuffer_tracking@fbcpsr-indfb-scaledprimary:
- shard-bmg: NOTRUN -> [SKIP][93] ([Intel XE#2313]) +46 other tests skip
[93]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcpsr-tiling-y:
- shard-bmg: NOTRUN -> [SKIP][94] ([Intel XE#2352])
[94]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][95] ([Intel XE#658])
[95]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][96] ([Intel XE#1469])
[96]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-blt:
- shard-dg2-set2: NOTRUN -> [SKIP][97] ([Intel XE#6312]) +9 other tests skip
[97]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-blt.html

* igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-msflip-blt:
- shard-dg2-set2: NOTRUN -> [SKIP][98] ([Intel XE#653]) +43 other tests skip
[98]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]

* igt@kms_hdr@bpc-switch:
- shard-bmg: NOTRUN -> [ABORT][99] ([Intel XE#6662]) +1 other test abort
[99]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]

* igt@kms_hdr@invalid-hdr:
- shard-bmg: NOTRUN -> [SKIP][100] ([Intel XE#1503])
[100]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_hdr@invalid-metadata-sizes:
- shard-lnl: NOTRUN -> [SKIP][101] ([Intel XE#1503]) +1 other test skip
[101]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@kms_pipe_crc_basic@suspend-read-crc@pipe-a-edp-1:
- shard-lnl: NOTRUN -> [ABORT][102] ([Intel XE#6675]) +12 other tests abort
[102]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@kms_pipe_crc_basic@[email protected]

* igt@kms_plane_lowres@tiling-x@pipe-b-edp-1:
- shard-lnl: NOTRUN -> [SKIP][103] ([Intel XE#599]) +7 other tests skip
[103]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@kms_plane_lowres@[email protected]

* igt@kms_plane_multiple@2x-tiling-none:
- shard-lnl: NOTRUN -> [SKIP][104] ([Intel XE#4596])
[104]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@kms_plane_multiple@2x-tiling-yf:
- shard-bmg: NOTRUN -> [SKIP][105] ([Intel XE#5021])
[105]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][106] ([Intel XE#5021])
[106]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]

* igt@kms_plane_multiple@tiling-y:
- shard-bmg: NOTRUN -> [SKIP][107] ([Intel XE#5020])
[107]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][108] ([Intel XE#5020])
[108]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]

* igt@kms_plane_multiple@tiling-yf:
- shard-lnl: NOTRUN -> [SKIP][109] ([Intel XE#5020]) +1 other test skip
[109]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5:
- shard-bmg: NOTRUN -> [SKIP][110] ([Intel XE#6691]) +9 other tests skip
[110]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5.html

* igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5@pipe-c:
- shard-lnl: NOTRUN -> [SKIP][111] ([Intel XE#6691]) +11 other tests skip
[111]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@kms_plane_scaling@[email protected]

* igt@kms_pm_backlight@fade:
- shard-bmg: NOTRUN -> [SKIP][112] ([Intel XE#870]) +1 other test skip
[112]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]

* igt@kms_pm_backlight@fade-with-suspend:
- shard-dg2-set2: NOTRUN -> [SKIP][113] ([Intel XE#870]) +1 other test skip
[113]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@kms_pm_dc@dc5-dpms:
- shard-dg2-set2: [PASS][114] -> [FAIL][115] ([Intel XE#718])
[114]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-463/igt@[email protected]
[115]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]

* igt@kms_pm_dc@dc5-psr:
- shard-bmg: NOTRUN -> [SKIP][116] ([Intel XE#2392]) +1 other test skip
[116]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][117] ([Intel XE#1129]) +1 other test skip
[117]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@kms_pm_dc@dc5-retention-flops:
- shard-dg2-set2: NOTRUN -> [SKIP][118] ([Intel XE#3309])
[118]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][119] ([Intel XE#3309])
[119]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]
- shard-bmg: NOTRUN -> [SKIP][120] ([Intel XE#3309])
[120]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@kms_pm_rpm@modeset-lpsp:
- shard-bmg: NOTRUN -> [SKIP][121] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#836]) +1 other test skip
[121]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@kms_psr2_sf@fbc-pr-cursor-plane-move-continuous-sf:
- shard-bmg: NOTRUN -> [SKIP][122] ([Intel XE#1406] / [Intel XE#1489]) +13 other tests skip
[122]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_psr2_sf@fbc-psr2-cursor-plane-move-continuous-exceed-fully-sf:
- shard-lnl: NOTRUN -> [SKIP][123] ([Intel XE#1406] / [Intel XE#2893] / [Intel XE#4608]) +3 other tests skip
[123]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_psr2_sf@fbc-psr2-cursor-plane-move-continuous-exceed-fully-sf.html

* igt@kms_psr2_sf@fbc-psr2-cursor-plane-move-continuous-exceed-fully-sf@pipe-b-edp-1:
- shard-lnl: NOTRUN -> [SKIP][124] ([Intel XE#1406] / [Intel XE#4608]) +7 other tests skip
[124]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_psr2_sf@fbc-psr2-cursor-plane-move-continuous-exceed-fully-sf@pipe-b-edp-1.html

* igt@kms_psr2_sf@pr-overlay-plane-move-continuous-sf:
- shard-lnl: NOTRUN -> [SKIP][125] ([Intel XE#1406] / [Intel XE#2893]) +9 other tests skip
[125]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@kms_psr2_sf@psr2-overlay-primary-update-sf-dmg-area:
- shard-dg2-set2: NOTRUN -> [SKIP][126] ([Intel XE#1406] / [Intel XE#1489]) +15 other tests skip
[126]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@kms_psr2_su@frontbuffer-xrgb8888:
- shard-lnl: NOTRUN -> [SKIP][127] ([Intel XE#1128] / [Intel XE#1406]) +1 other test skip
[127]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@kms_psr2_su@page_flip-nv12:
- shard-bmg: NOTRUN -> [SKIP][128] ([Intel XE#1406] / [Intel XE#2387])
[128]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@kms_psr2_su@page_flip-nv12.html

* igt@kms_psr@fbc-psr2-no-drrs@edp-1:
- shard-lnl: NOTRUN -> [SKIP][129] ([Intel XE#1406] / [Intel XE#4609]) +1 other test skip
[129]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_psr@[email protected]

* igt@kms_psr@pr-no-drrs:
- shard-lnl: NOTRUN -> [SKIP][130] ([Intel XE#1406]) +10 other tests skip
[130]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@kms_psr@psr-basic:
- shard-bmg: NOTRUN -> [SKIP][131] ([Intel XE#1406] / [Intel XE#2234] / [Intel XE#2850]) +27 other tests skip
[131]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]

* igt@kms_psr@psr-dpms:
- shard-dg2-set2: NOTRUN -> [SKIP][132] ([Intel XE#1406] / [Intel XE#2850] / [Intel XE#929]) +23 other tests skip
[132]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]

* igt@kms_psr@psr2-primary-render:
- shard-bmg: NOTRUN -> [SKIP][133] ([Intel XE#1406] / [Intel XE#2234])
[133]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_psr@psr2-suspend@edp-1:
- shard-lnl: NOTRUN -> [ABORT][134] ([Intel XE#2625] / [Intel XE#6675]) +3 other tests abort
[134]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@kms_psr@[email protected]

* igt@kms_psr_stress_test@flip-primary-invalidate-overlay:
- shard-bmg: NOTRUN -> [SKIP][135] ([Intel XE#1406] / [Intel XE#2414])
[135]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][136] ([Intel XE#1406] / [Intel XE#2939])
[136]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@kms_rotation_crc@primary-rotation-90:
- shard-bmg: NOTRUN -> [SKIP][137] ([Intel XE#3414] / [Intel XE#3904]) +1 other test skip
[137]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_rotation_crc@primary-y-tiled-reflect-x-0:
- shard-bmg: NOTRUN -> [SKIP][138] ([Intel XE#2330]) +1 other test skip
[138]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][139] ([Intel XE#1127])
[139]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]

* igt@kms_rotation_crc@primary-yf-tiled-reflect-x-0:
- shard-dg2-set2: NOTRUN -> [SKIP][140] ([Intel XE#1127])
[140]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]

* igt@kms_rotation_crc@primary-yf-tiled-reflect-x-90:
- shard-dg2-set2: NOTRUN -> [SKIP][141] ([Intel XE#3414])
[141]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][142] ([Intel XE#3414] / [Intel XE#3904])
[142]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]

* igt@kms_setmode@clone-exclusive-crtc:
- shard-bmg: NOTRUN -> [SKIP][143] ([Intel XE#1435]) +1 other test skip
[143]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_setmode@invalid-clone-single-crtc:
- shard-lnl: NOTRUN -> [SKIP][144] ([Intel XE#1435])
[144]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@kms_setmode@invalid-clone-single-crtc-stealing:
- shard-bmg: [PASS][145] -> [SKIP][146] ([Intel XE#1435])
[145]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@[email protected]
[146]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_sharpness_filter@invalid-filter-with-scaler:
- shard-bmg: NOTRUN -> [SKIP][147] ([Intel XE#6503]) +2 other tests skip
[147]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]

* igt@kms_vrr@cmrr:
- shard-dg2-set2: NOTRUN -> [SKIP][148] ([Intel XE#2168])
[148]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]

* igt@kms_vrr@cmrr@pipe-a-edp-1:
- shard-lnl: NOTRUN -> [FAIL][149] ([Intel XE#4459]) +1 other test fail
[149]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_vrr@[email protected]

* igt@kms_vrr@flip-basic:
- shard-bmg: NOTRUN -> [SKIP][150] ([Intel XE#1499]) +1 other test skip
[150]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@kms_vrr@flipline:
- shard-dg2-set2: NOTRUN -> [SKIP][151] ([Intel XE#455]) +26 other tests skip
[151]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@kms_vrr@seamless-rr-switch-virtual@pipe-a-edp-1:
- shard-lnl: [PASS][152] -> [FAIL][153] ([Intel XE#2142]) +1 other test fail
[152]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-8/igt@kms_vrr@[email protected]
[153]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@kms_vrr@[email protected]

* igt@sriov_basic@enable-vfs-bind-unbind-each-numvfs-all:
- shard-dg2-set2: NOTRUN -> [SKIP][154] ([Intel XE#1091] / [Intel XE#2849])
[154]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][155] ([Intel XE#1091] / [Intel XE#2849])
[155]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@xe_copy_basic@mem-page-copy-17:
- shard-dg2-set2: NOTRUN -> [SKIP][156] ([Intel XE#5300]) +2 other tests skip
[156]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@xe_copy_basic@mem-set-linear-0xfffe:
- shard-dg2-set2: NOTRUN -> [SKIP][157] ([Intel XE#1126]) +3 other tests skip
[157]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]

* igt@xe_create@create-big-vram:
- shard-lnl: NOTRUN -> [SKIP][158] ([Intel XE#1062])
[158]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]

* igt@xe_eu_stall@non-blocking-re-enable:
- shard-dg2-set2: NOTRUN -> [SKIP][159] ([Intel XE#5626]) +1 other test skip
[159]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]

* igt@xe_eudebug@vm-bind-clear-faultable:
- shard-dg2-set2: NOTRUN -> [SKIP][160] ([Intel XE#4837]) +21 other tests skip
[160]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-466/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][161] ([Intel XE#4837]) +15 other tests skip
[161]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@xe_eudebug_online@set-breakpoint-sigint-debugger:
- shard-bmg: NOTRUN -> [SKIP][162] ([Intel XE#4837]) +18 other tests skip
[162]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@xe_evict@evict-beng-mixed-threads-large-multi-vm:
- shard-lnl: NOTRUN -> [SKIP][163] ([Intel XE#688]) +16 other tests skip
[163]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@xe_exec_basic@multigpu-no-exec-bindexecqueue:
- shard-bmg: NOTRUN -> [SKIP][164] ([Intel XE#2322]) +14 other tests skip
[164]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]

* igt@xe_exec_basic@multigpu-no-exec-userptr:
- shard-lnl: NOTRUN -> [SKIP][165] ([Intel XE#1392]) +15 other tests skip
[165]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@xe_exec_fault_mode@twice-bindexecqueue-userptr-rebind-prefetch:
- shard-dg2-set2: NOTRUN -> [SKIP][166] ([Intel XE#288]) +32 other tests skip
[166]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@xe_exec_fault_mode@twice-bindexecqueue-userptr-rebind-prefetch.html

* igt@xe_exec_mix_modes@exec-spinner-interrupted-lr:
- shard-dg2-set2: NOTRUN -> [SKIP][167] ([Intel XE#2360])
[167]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@xe_exec_system_allocator@many-64k-mmap-huge-nomemset:
- shard-lnl: NOTRUN -> [SKIP][168] ([Intel XE#5007]) +1 other test skip
[168]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]

* igt@xe_exec_system_allocator@many-64k-mmap-mlock-nomemset:
- shard-dg2-set2: NOTRUN -> [SKIP][169] ([Intel XE#4915]) +500 other tests skip
[169]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@xe_exec_system_allocator@many-64k-mmap-new-huge:
- shard-bmg: NOTRUN -> [SKIP][170] ([Intel XE#5007]) +1 other test skip
[170]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@[email protected]

* igt@xe_exec_system_allocator@pat-index-madvise-pat-idx-uc-comp-multi-vma:
- shard-lnl: NOTRUN -> [SKIP][171] ([Intel XE#6196])
[171]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@xe_exec_system_allocator@pat-index-madvise-pat-idx-uc-comp-multi-vma.html

* igt@xe_exec_system_allocator@threads-many-mmap-new-huge-nomemset:
- shard-bmg: NOTRUN -> [SKIP][172] ([Intel XE#4943]) +31 other tests skip
[172]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@xe_exec_system_allocator@threads-many-mmap-new-huge-nomemset.html

* igt@xe_exec_system_allocator@threads-shared-vm-many-execqueues-mmap-free-huge:
- shard-lnl: NOTRUN -> [SKIP][173] ([Intel XE#4943]) +26 other tests skip
[173]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@xe_exec_system_allocator@threads-shared-vm-many-execqueues-mmap-free-huge.html

* igt@xe_exec_system_allocator@twice-large-malloc-prefetch-madvise:
- shard-lnl: NOTRUN -> [WARN][174] ([Intel XE#5786]) +2 other tests warn
[174]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@xe_exec_system_allocator@twice-large-malloc-prefetch-madvise.html

* igt@xe_fault_injection@exec-queue-create-fail-xe_pxp_exec_queue_add:
- shard-bmg: NOTRUN -> [SKIP][175] ([Intel XE#6281])
[175]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@xe_fault_injection@exec-queue-create-fail-xe_pxp_exec_queue_add.html
- shard-dg2-set2: NOTRUN -> [SKIP][176] ([Intel XE#6281])
[176]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@xe_fault_injection@exec-queue-create-fail-xe_pxp_exec_queue_add.html

* igt@xe_live_ktest@xe_bo@xe_bo_evict_kunit:
- shard-lnl: NOTRUN -> [SKIP][177] ([Intel XE#2229]) +1 other test skip
[177]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@xe_live_ktest@xe_bo@xe_bo_evict_kunit.html

* igt@xe_live_ktest@xe_eudebug:
- shard-lnl: NOTRUN -> [SKIP][178] ([Intel XE#2833])
[178]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@xe_live_ktest@xe_eudebug.html

* igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit:
- shard-dg2-set2: NOTRUN -> [SKIP][179] ([Intel XE#2229])
[179]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit.html

* igt@xe_mmap@pci-membarrier:
- shard-lnl: NOTRUN -> [SKIP][180] ([Intel XE#5100])
[180]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@xe_module_load@force-load:
- shard-bmg: NOTRUN -> [SKIP][181] ([Intel XE#2457])
[181]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][182] ([Intel XE#378])
[182]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]

* igt@xe_oa@oa-unit-exclusive-stream-sample-oa:
- shard-dg2-set2: NOTRUN -> [SKIP][183] ([Intel XE#3573]) +7 other tests skip
[183]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@xe_oa@tail-address-wrap:
- shard-dg2-set2: NOTRUN -> [SKIP][184] ([Intel XE#6032])
[184]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]

* igt@xe_pat@display-vs-wb-transient:
- shard-dg2-set2: NOTRUN -> [SKIP][185] ([Intel XE#1337])
[185]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@xe_peer2peer@read:
- shard-bmg: NOTRUN -> [SKIP][186] ([Intel XE#2427]) +1 other test skip
[186]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@xe_pm@d3cold-basic:
- shard-lnl: NOTRUN -> [SKIP][187] ([Intel XE#2284] / [Intel XE#366]) +1 other test skip
[187]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]

* igt@xe_pm@s2idle-d3cold-basic-exec:
- shard-bmg: NOTRUN -> [SKIP][188] ([Intel XE#2284]) +2 other tests skip
[188]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]
- shard-dg2-set2: NOTRUN -> [SKIP][189] ([Intel XE#2284] / [Intel XE#366]) +1 other test skip
[189]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]

* igt@xe_pm@s2idle-exec-after:
- shard-dg2-set2: NOTRUN -> [ABORT][190] ([Intel XE#6675]) +18 other tests abort
[190]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]

* igt@xe_pm@s3-mocs:
- shard-lnl: NOTRUN -> [SKIP][191] ([Intel XE#584]) +2 other tests skip
[191]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@xe_pm@s4-multiple-execs:
- shard-lnl: [PASS][192] -> [ABORT][193] ([Intel XE#6675])
[192]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-4/igt@[email protected]
[193]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

* igt@xe_pm@vram-d3cold-threshold:
- shard-dg2-set2: NOTRUN -> [SKIP][194] ([Intel XE#579])
[194]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]
- shard-bmg: NOTRUN -> [SKIP][195] ([Intel XE#579])
[195]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@xe_pmu@all-fn-engine-activity-load:
- shard-dg2-set2: NOTRUN -> [SKIP][196] ([Intel XE#4650])
[196]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]

* igt@xe_pxp@display-pxp-fb:
- shard-bmg: NOTRUN -> [SKIP][197] ([Intel XE#4733]) +2 other tests skip
[197]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]

* igt@xe_pxp@pxp-termination-key-update-post-suspend:
- shard-dg2-set2: NOTRUN -> [SKIP][198] ([Intel XE#4733]) +2 other tests skip
[198]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]

* igt@xe_query@multigpu-query-engines:
- shard-dg2-set2: NOTRUN -> [SKIP][199] ([Intel XE#944]) +7 other tests skip
[199]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]

* igt@xe_query@multigpu-query-invalid-size:
- shard-lnl: NOTRUN -> [SKIP][200] ([Intel XE#944]) +4 other tests skip
[200]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@xe_query@multigpu-query-mem-usage:
- shard-bmg: NOTRUN -> [SKIP][201] ([Intel XE#944]) +8 other tests skip
[201]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@[email protected]

* igt@xe_render_copy@render-stress-0-copies:
- shard-dg2-set2: NOTRUN -> [SKIP][202] ([Intel XE#4814])
[202]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@xe_sriov_auto_provisioning@exclusive-ranges:
- shard-dg2-set2: NOTRUN -> [SKIP][203] ([Intel XE#4130]) +2 other tests skip
[203]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]

* igt@xe_sriov_auto_provisioning@fair-allocation:
- shard-lnl: NOTRUN -> [SKIP][204] ([Intel XE#4130]) +2 other tests skip
[204]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@xe_sriov_flr@flr-twice:
- shard-dg2-set2: NOTRUN -> [SKIP][205] ([Intel XE#4273])
[205]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]

* igt@xe_sriov_vram@vf-access-provisioned:
- shard-dg2-set2: NOTRUN -> [SKIP][206] ([Intel XE#6318])
[206]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]

* igt@xe_survivability@i2c-functionality:
- shard-dg2-set2: NOTRUN -> [SKIP][207] ([Intel XE#6529])
[207]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-466/igt@[email protected]
- shard-lnl: NOTRUN -> [SKIP][208] ([Intel XE#6529])
[208]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]

* igt@xe_vm@out-of-memory:
- shard-lnl: NOTRUN -> [SKIP][209] ([Intel XE#5745])
[209]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]

#### Possible fixes ####

* igt@kms_flip@2x-blocking-absolute-wf_vblank-interruptible:
- shard-bmg: [SKIP][210] ([Intel XE#2316]) -> [PASS][211]
[210]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-2/igt@kms_flip@2x-blocking-absolute-wf_vblank-interruptible.html
[211]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@kms_flip@2x-blocking-absolute-wf_vblank-interruptible.html

* igt@kms_psr_stress_test@invalidate-primary-flip-overlay:
- shard-lnl: [SKIP][212] ([Intel XE#1406] / [Intel XE#4692]) -> [PASS][213]
[212]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-1/igt@[email protected]
[213]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

* igt@kms_vblank@ts-continuation-dpms-suspend@pipe-c-edp-1:
- shard-lnl: [INCOMPLETE][214] ([Intel XE#4488]) -> [PASS][215]
[214]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-7/igt@kms_vblank@[email protected]
[215]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@kms_vblank@[email protected]

* igt@xe_exec_system_allocator@process-many-execqueues-mmap-remap-eocheck:
- shard-bmg: [ABORT][216] ([Intel XE#3970]) -> [PASS][217]
[216]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-2/igt@xe_exec_system_allocator@process-many-execqueues-mmap-remap-eocheck.html
[217]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@xe_exec_system_allocator@process-many-execqueues-mmap-remap-eocheck.html

* igt@xe_module_load@load:
- shard-lnl: ([PASS][218], [PASS][219], [PASS][220], [PASS][221], [PASS][222], [PASS][223], [PASS][224], [PASS][225], [PASS][226], [PASS][227], [PASS][228], [PASS][229], [PASS][230], [PASS][231], [PASS][232], [PASS][233], [SKIP][234], [PASS][235], [PASS][236], [PASS][237], [PASS][238], [PASS][239], [PASS][240], [PASS][241], [PASS][242], [PASS][243]) ([Intel XE#378]) -> ([PASS][244], [PASS][245], [PASS][246], [PASS][247], [PASS][248], [PASS][249], [PASS][250], [PASS][251], [PASS][252], [PASS][253], [PASS][254], [PASS][255], [PASS][256], [PASS][257], [PASS][258], [PASS][259], [PASS][260], [PASS][261], [PASS][262], [PASS][263], [PASS][264], [PASS][265], [PASS][266], [PASS][267], [PASS][268])
[218]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-7/igt@[email protected]
[219]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-7/igt@[email protected]
[220]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-5/igt@[email protected]
[221]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-4/igt@[email protected]
[222]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-4/igt@[email protected]
[223]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-3/igt@[email protected]
[224]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-3/igt@[email protected]
[225]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-3/igt@[email protected]
[226]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-2/igt@[email protected]
[227]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-2/igt@[email protected]
[228]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-8/igt@[email protected]
[229]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-7/igt@[email protected]
[230]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-1/igt@[email protected]
[231]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-4/igt@[email protected]
[232]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-4/igt@[email protected]
[233]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-1/igt@[email protected]
[234]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-8/igt@[email protected]
[235]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-1/igt@[email protected]
[236]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-8/igt@[email protected]
[237]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-8/igt@[email protected]
[238]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-8/igt@[email protected]
[239]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-3/igt@[email protected]
[240]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-5/igt@[email protected]
[241]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-5/igt@[email protected]
[242]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-2/igt@[email protected]
[243]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-2/igt@[email protected]
[244]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]
[245]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]
[246]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]
[247]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]
[248]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]
[249]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]
[250]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]
[251]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]
[252]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]
[253]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]
[254]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]
[255]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]
[256]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-2/igt@[email protected]
[257]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]
[258]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]
[259]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-5/igt@[email protected]
[260]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-4/igt@[email protected]
[261]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]
[262]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]
[263]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]
[264]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-8/igt@[email protected]
[265]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]
[266]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]
[267]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]
[268]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-1/igt@[email protected]
- shard-bmg: ([PASS][269], [PASS][270], [PASS][271], [PASS][272], [PASS][273], [PASS][274], [PASS][275], [PASS][276], [PASS][277], [PASS][278], [PASS][279], [PASS][280], [PASS][281], [PASS][282], [PASS][283], [PASS][284], [PASS][285], [SKIP][286], [PASS][287], [PASS][288], [PASS][289], [PASS][290], [PASS][291], [PASS][292], [PASS][293]) ([Intel XE#2457]) -> ([PASS][294], [PASS][295], [PASS][296], [PASS][297], [PASS][298], [PASS][299], [PASS][300], [PASS][301], [PASS][302], [PASS][303], [PASS][304], [PASS][305], [PASS][306], [PASS][307], [PASS][308], [PASS][309], [PASS][310], [PASS][311], [PASS][312], [PASS][313], [PASS][314], [PASS][315], [PASS][316], [PASS][317], [PASS][318])
[269]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-1/igt@[email protected]
[270]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-6/igt@[email protected]
[271]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-1/igt@[email protected]
[272]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-2/igt@[email protected]
[273]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-1/igt@[email protected]
[274]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-8/igt@[email protected]
[275]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-8/igt@[email protected]
[276]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-3/igt@[email protected]
[277]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@[email protected]
[278]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-6/igt@[email protected]
[279]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@[email protected]
[280]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-7/igt@[email protected]
[281]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-2/igt@[email protected]
[282]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-4/igt@[email protected]
[283]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-8/igt@[email protected]
[284]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@[email protected]
[285]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-4/igt@[email protected]
[286]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@[email protected]
[287]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-4/igt@[email protected]
[288]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-7/igt@[email protected]
[289]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-7/igt@[email protected]
[290]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-3/igt@[email protected]
[291]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-3/igt@[email protected]
[292]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-1/igt@[email protected]
[293]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-2/igt@[email protected]
[294]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]
[295]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]
[296]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]
[297]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]
[298]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@[email protected]
[299]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@[email protected]
[300]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-7/igt@[email protected]
[301]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]
[302]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]
[303]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]
[304]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]
[305]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]
[306]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-1/igt@[email protected]
[307]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-3/igt@[email protected]
[308]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
[309]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
[310]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]
[311]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]
[312]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-4/igt@[email protected]
[313]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-4/igt@[email protected]
[314]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-4/igt@[email protected]
[315]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]
[316]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]
[317]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]
[318]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-5/igt@[email protected]
- shard-dg2-set2: ([PASS][319], [PASS][320], [SKIP][321], [PASS][322], [PASS][323], [PASS][324], [PASS][325], [PASS][326], [PASS][327], [PASS][328], [PASS][329], [PASS][330], [PASS][331], [PASS][332], [PASS][333], [PASS][334], [PASS][335], [PASS][336], [PASS][337], [PASS][338], [PASS][339], [PASS][340], [PASS][341], [PASS][342], [PASS][343], [PASS][344]) ([Intel XE#378]) -> ([PASS][345], [PASS][346], [PASS][347], [PASS][348], [PASS][349], [PASS][350], [PASS][351], [PASS][352], [PASS][353], [PASS][354], [PASS][355], [PASS][356], [PASS][357], [PASS][358], [PASS][359], [PASS][360], [PASS][361], [PASS][362], [PASS][363], [PASS][364], [PASS][365], [PASS][366], [PASS][367], [PASS][368], [PASS][369])
[319]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-436/igt@[email protected]
[320]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-466/igt@[email protected]
[321]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-436/igt@[email protected]
[322]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-434/igt@[email protected]
[323]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-434/igt@[email protected]
[324]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-463/igt@[email protected]
[325]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-466/igt@[email protected]
[326]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-463/igt@[email protected]
[327]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-434/igt@[email protected]
[328]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-435/igt@[email protected]
[329]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-436/igt@[email protected]
[330]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-436/igt@[email protected]
[331]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-436/igt@[email protected]
[332]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-435/igt@[email protected]
[333]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-433/igt@[email protected]
[334]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-433/igt@[email protected]
[335]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-432/igt@[email protected]
[336]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-463/igt@[email protected]
[337]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-466/igt@[email protected]
[338]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-433/igt@[email protected]
[339]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-433/igt@[email protected]
[340]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-464/igt@[email protected]
[341]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-435/igt@[email protected]
[342]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-432/igt@[email protected]
[343]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-432/igt@[email protected]
[344]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-dg2-432/igt@[email protected]
[345]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]
[346]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]
[347]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]
[348]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-436/igt@[email protected]
[349]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]
[350]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
[351]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]
[352]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-433/igt@[email protected]
[353]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]
[354]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]
[355]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
[356]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-432/igt@[email protected]
[357]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-464/igt@[email protected]
[358]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]
[359]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]
[360]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]
[361]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-434/igt@[email protected]
[362]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]
[363]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]
[364]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]
[365]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-463/igt@[email protected]
[366]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-466/igt@[email protected]
[367]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]
[368]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]
[369]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-dg2-435/igt@[email protected]

* igt@xe_pmu@engine-activity-accuracy-50:
- shard-lnl: [FAIL][370] ([Intel XE#6251]) -> [PASS][371] +2 other tests pass
[370]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-lnl-2/igt@[email protected]
[371]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-lnl-3/igt@[email protected]

#### Warnings ####

* igt@kms_content_protection@legacy:
- shard-bmg: [FAIL][372] ([Intel XE#1178]) -> [SKIP][373] ([Intel XE#2341])
[372]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-4/igt@[email protected]
[373]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-6/igt@[email protected]

* igt@kms_content_protection@suspend-resume:
- shard-bmg: [FAIL][374] ([Intel XE#1178]) -> [SKIP][375] ([Intel XE#6705])
[374]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@[email protected]
[375]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@drrs-2p-pri-indfb-multidraw:
- shard-bmg: [SKIP][376] ([Intel XE#2312]) -> [SKIP][377] ([Intel XE#2311])
[376]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-6/igt@[email protected]
[377]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-4/igt@[email protected]

* igt@kms_frontbuffer_tracking@drrs-2p-primscrn-shrfb-msflip-blt:
- shard-bmg: [SKIP][378] ([Intel XE#2311]) -> [SKIP][379] ([Intel XE#2312]) +6 other tests skip
[378]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-1/igt@[email protected]
[379]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc:
- shard-bmg: [SKIP][380] ([Intel XE#4141]) -> [SKIP][381] ([Intel XE#2312]) +2 other tests skip
[380]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-5/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc.html
[381]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-indfb-draw-mmap-wc.html

* igt@kms_frontbuffer_tracking@psr-2p-primscrn-spr-indfb-draw-blt:
- shard-bmg: [SKIP][382] ([Intel XE#2312]) -> [SKIP][383] ([Intel XE#2313])
[382]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-2/igt@[email protected]
[383]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-8/igt@[email protected]

* igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-plflip-blt:
- shard-bmg: [SKIP][384] ([Intel XE#2313]) -> [SKIP][385] ([Intel XE#2312]) +6 other tests skip
[384]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8645/shard-bmg-1/igt@[email protected]
[385]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/shard-bmg-2/igt@[email protected]

{name}: This element is suppressed. This means it is ignored when computing
the status of the difference (SUCCESS, WARNING, or FAILURE).

[Intel XE#1062]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1062
[Intel XE#1091]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1091
[Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
[Intel XE#1126]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1126
[Intel XE#1127]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1127
[Intel XE#1128]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1128
[Intel XE#1129]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1129
[Intel XE#1138]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1138
[Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
[Intel XE#1337]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1337
[Intel XE#1392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1392
[Intel XE#1397]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1397
[Intel XE#1401]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1401
[Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406
[Intel XE#1407]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1407
[Intel XE#1421]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1421
[Intel XE#1424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1424
[Intel XE#1428]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1428
[Intel XE#1435]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1435
[Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439
[Intel XE#1469]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1469
[Intel XE#1477]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1477
[Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
[Intel XE#1499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1499
[Intel XE#1503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1503
[Intel XE#1512]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1512
[Intel XE#1745]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1745
[Intel XE#2142]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2142
[Intel XE#2168]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2168
[Intel XE#2191]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2191
[Intel XE#2229]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2229
[Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
[Intel XE#2244]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2244
[Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
[Intel XE#2284]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2284
[Intel XE#2286]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2286
[Intel XE#2291]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2291
[Intel XE#2293]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2293
[Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
[Intel XE#2312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2312
[Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
[Intel XE#2314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2314
[Intel XE#2316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2316
[Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
[Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321
[Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
[Intel XE#2325]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2325
[Intel XE#2327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2327
[Intel XE#2330]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2330
[Intel XE#2341]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2341
[Intel XE#2352]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2352
[Intel XE#2360]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2360
[Intel XE#2380]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2380
[Intel XE#2387]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2387
[Intel XE#2390]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2390
[Intel XE#2392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2392
[Intel XE#2414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2414
[Intel XE#2427]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2427
[Intel XE#2457]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2457
[Intel XE#2625]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2625
[Intel XE#2652]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2652
[Intel XE#2669]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2669
[Intel XE#2705]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2705
[Intel XE#2724]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2724
[Intel XE#2833]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2833
[Intel XE#2849]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2849
[Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
[Intel XE#288]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/288
[Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
[Intel XE#2893]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2893
[Intel XE#2894]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2894
[Intel XE#2907]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2907
[Intel XE#2939]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2939
[Intel XE#306]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/306
[Intel XE#307]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/307
[Intel XE#308]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/308
[Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
[Intel XE#3106]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3106
[Intel XE#3141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3141
[Intel XE#316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/316
[Intel XE#323]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/323
[Intel XE#3278]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3278
[Intel XE#3309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3309
[Intel XE#3414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3414
[Intel XE#3432]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3432
[Intel XE#352]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/352
[Intel XE#3573]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3573
[Intel XE#3658]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3658
[Intel XE#366]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/366
[Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
[Intel XE#373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/373
[Intel XE#378]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/378
[Intel XE#3904]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3904
[Intel XE#3970]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3970
[Intel XE#4130]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4130
[Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
[Intel XE#4156]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4156
[Intel XE#4212]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4212
[Intel XE#4273]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4273
[Intel XE#4331]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4331
[Intel XE#4345]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4345
[Intel XE#4416]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4416
[Intel XE#4417]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4417
[Intel XE#4418]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4418
[Intel XE#4459]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4459
[Intel XE#4488]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4488
[Intel XE#455]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/455
[Intel XE#4596]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4596
[Intel XE#4608]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4608
[Intel XE#4609]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4609
[Intel XE#4650]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4650
[Intel XE#4683]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4683
[Intel XE#4692]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4692
[Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733
[Intel XE#4814]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4814
[Intel XE#4837]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4837
[Intel XE#4915]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4915
[Intel XE#4943]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4943
[Intel XE#5007]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5007
[Intel XE#5020]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5020
[Intel XE#5021]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5021
[Intel XE#5100]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5100
[Intel XE#5299]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5299
[Intel XE#5300]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5300
[Intel XE#5626]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5626
[Intel XE#5745]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5745
[Intel XE#5786]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5786
[Intel XE#579]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/579
[Intel XE#584]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/584
[Intel XE#599]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/599
[Intel XE#6014]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6014
[Intel XE#6032]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6032
[Intel XE#607]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/607
[Intel XE#610]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/610
[Intel XE#6196]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6196
[Intel XE#6251]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6251
[Intel XE#6281]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6281
[Intel XE#6312]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6312
[Intel XE#6318]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6318
[Intel XE#6503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6503
[Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
[Intel XE#6529]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6529
[Intel XE#653]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/653
[Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
[Intel XE#658]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/658
[Intel XE#6662]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6662
[Intel XE#6675]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6675
[Intel XE#6676]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6676
[Intel XE#6691]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6691
[Intel XE#6704]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6704
[Intel XE#6705]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6705
[Intel XE#688]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/688
[Intel XE#718]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/718
[Intel XE#787]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/787
[Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836
[Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870
[Intel XE#929]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/929
[Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944

Build changes
-------------

* IGT: IGT_8645 -> IGTPW_14134
* Linux: xe-4166-e1c1b3e03e356d1e20432dcb0d38ad44d5e92670 -> xe-4172-97dd55b95199516099b8b5871ba2bd3450a3dd83

IGTPW_14134: b65fda72613cfe245a286902212314d01e6cfdd5 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8645: 8645
xe-4166-e1c1b3e03e356d1e20432dcb0d38ad44d5e92670: e1c1b3e03e356d1e20432dcb0d38ad44d5e92670 xe-4172-97dd55b95199516099b8b5871ba2bd3450a3dd83: 97dd55b95199516099b8b5871ba2bd3450a3dd83

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14134/index.html