Madvise feature in Multi-GPU
cover Madvise feature in Multi-GPU
From: Nishit Sharma <[email protected]>
This patch series adds comprehensive SVM multi-GPU IGT test coverage for madvise and prefetch functionality. The following tests are introduced in tests/intel/xe_multi-gpusvm.c:-
1. Cross-GPU Memory Access Test: Allocates a shared SVM buffer,
writes data from one GPU, and verifies correct access from another GPU and the CPU.
2. Atomic Operations Test: Performs atomic increment operation on a shared SVM buffer
from both GPUs and the CPU, verifying correctness and ordering.
3. Coherency Test: Validates memory coherency by writing data from one GPU and reading
from another GPU and the CPU without explicit synchronization.
4. Performance Test: Measures latency and bandwidth for buffer access from each GPU and the CPU comparing local versus remote access in SVM.
5. Fault Handling Test: Intentionally triggers page faults by accessing non prefetch SVM regions from both GPUs verifying that faults are detected and resolved correctly.
6. Simultaneous Access Test: Launches compute or copy workloads on both GPUs accessing the same SVM buffer using synchronization primitives to coordinate access and verify data integrity.
7. Conflicting Madvise Test: Applies conflicting madvise operations across GPUs, ensuring the driver detects and reports conflicts or errors when preferred locations differ.
Nishit Sharma (7):
tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU cross-GPU memory
access test
tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU atomic operations tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU coherency test tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU performance test tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU fault handling test tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU simultaneous access
test
tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU conflicting madvise
test
lib/xe/xe_ioctl.c | 40 + lib/xe/xe_ioctl.h | 5 + tags | 263672 +++++++++++++++++++++++++++++++ tests/intel/xe_multi_gpusvm.c | 1379 + tests/intel/xe_multisvm.c | 41 +- tests/meson.build | 1 + 6 files changed, 265100 insertions(+), 38 deletions(-) create mode 100644 tags create mode 100644 tests/intel/xe_multi_gpusvm.c
Signature · 1 line
2.48.1
PATCH 1/7 tests/intel/xe_multi-gpusvm.c: Add SVM multi-GPU cross-GPU memory access test
From: Nishit Sharma <[email protected]>
his test allocates a buffer in SVM, writes data to it from GPU 1, and reads/verifies the data from GPU 2. 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.
--- lib/xe/xe_ioctl.c | 40 +++++ lib/xe/xe_ioctl.h | 5 + tests/intel/xe_multi_gpusvm.c | 265 ++++++++++++++++++++++++++++++++++ tests/intel/xe_multisvm.c | 41 +----- tests/meson.build | 1 + 5 files changed, 314 insertions(+), 38 deletions(-) create mode 100644 tests/intel/xe_multi_gpusvm.c
lib/xe/xe_ioctl.c +40 -0
@@ -746,3 +746,43 @@ 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); +} +
lib/xe/xe_ioctl.h +5 -0
@@ -109,4 +109,9 @@ int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_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_multi_gpusvm.c new file +265 -0
265 lines not on this page · raw message
tests/intel/xe_multisvm.c +3 -38
62 lines not on this page · raw message
tests/meson.build +1 -0
@@ -313,6 +313,7 @@ intel_xe_progs = [ 'xe_mmap', 'xe_module_load', 'xe_multisvm', + 'xe_multi_gpusvm', 'xe_noexec_ping_pong', 'xe_oa', 'xe_pat',
Signature · 1 line
2.48.1
PATCH 2/7 tests/intel/xe_multi-gpusvm.c: 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 | 186 ++++++++++++++++++++++++++++++++++ 1 file changed, 186 insertions(+)
tests/intel/xe_multi_gpusvm.c +186 -0
@@ -31,6 +31,11 @@* region both remotely and locally and copies to it. Reads back to * system memory and checks the result. * +* SUBTEST: atomic-inc-gpu-op +* Description: +* This test does atomic operation in multi-gpu by executing atomic +* operation on GPU1 and then atomic operation on GPU2 using same +* adress */ #define MAX_XE_REGIONS 8
@@ -40,6 +45,7 @@#define BIND_SYNC_VAL 0x686868#define EXEC_SYNC_VAL 0x676767#define COPY_SIZE SZ_64M +#define ATOMIC_OP_VAL 56struct xe_svm_gpu_info {bool supports_faults;
@@ -49,8 +55,45 @@ struct xe_svm_gpu_info {int fd; }; +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 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)
@@ -222,6 +265,144 @@ gpu_mem_access(struct xe_svm_gpu_info *src_gpu,copy_src_dst (src_gpu, dst_gpu, eci); } +static void +atomic_inc_op (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci, +bool prefetch_req) +{ +uint64_t addr; +uint32_t vm[2 ]; +uint32_t exec_queue[2 ]; +uint32_t batch_bo; +struct test_exec_data *data; +uint64_t batch_addr; +struct drm_xe_sync sync = {}; +volatile uint64_t *sync_addr; +volatile uint32_t *shared_val; + + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE | +DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits, +DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE | +DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,0 ,1ull << gpu1->va_bits, +DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + data =aligned_alloc (SZ_2M ,SZ_4K ); +igt_assert (data); + data[0 ].vm_sync =0 ; + addr =to_user_pointer (data); + + shared_val = (volatile uint32_t *)addr; + *shared_val =ATOMIC_OP_VAL -1 ; + +atomic_batch_init (gpu0->fd, vm[0 ], addr, &batch_bo, &batch_addr); + +/* Place destination in an optionally remote location to test */ +xe_vm_madvise (gpu0->fd, vm[0 ], addr,SZ_4K ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +if (prefetch_req) { +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , addr, +SZ_4K , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , + exec_queue[0 ],NSEC_PER_SEC *10 ); + } +free ((void *)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 ; + *sync_addr =0 ; + +/* Executing ATOMIC_INC on GPU0. */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + +igt_assert_eq (*shared_val,ATOMIC_OP_VAL ); + +atomic_batch_init (gpu1->fd, vm[1 ], addr, &batch_bo, &batch_addr); + +/* Place destination in an optionally remote location to test */ +xe_vm_madvise (gpu1->fd, vm[1 ], addr,SZ_4K ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +if (prefetch_req) { +xe_vm_prefetch_async (gpu1->fd, vm[1 ],0 ,0 , addr, +SZ_4K , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , + exec_queue[1 ],NSEC_PER_SEC *10 ); + } +free ((void *)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 ; + *sync_addr =0 ; + +/* Execute ATOMIC_INC on GPU1 */ +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + +igt_assert_eq (*shared_val,ATOMIC_OP_VAL +1 ); + +munmap ((void *)batch_addr,BATCH_SIZE (gpu0->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo, batch_addr); +batch_fini (gpu1->fd, vm[1 ], batch_bo, batch_addr); +free (data); + +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); +} + +static void +gpu_atomic_inc (struct xe_svm_gpu_info *src_gpu, +struct xe_svm_gpu_info *dst_gpu, +struct drm_xe_engine_class_instance *eci, +bool prefetch_req) +{ +igt_assert (src_gpu); +igt_assert (dst_gpu); + +atomic_inc_op (src_gpu, dst_gpu, eci, prefetch_req); +} + igt_main {struct xe_svm_gpu_info gpus[MAX_XE_GPUS ];
@@ -256,6 +437,11 @@ igt_main igt_subtest("cross-gpu-mem-access")gpu_mem_access (&gpus[0 ], &gpus[1 ], &eci); + igt_subtest("atomic-inc-gpu-op") { +gpu_atomic_inc (&gpus[0 ], &gpus[1 ], &eci,1 ); +gpu_atomic_inc (&gpus[0 ], &gpus[1 ], &eci,0 ); + } + igt_fixture {int cnt;
Signature · 1 line
2.48.1
PATCH 3/7 tests/intel/xe_multi-gpusvm.c: 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 | 222 +++++++++++++++++++++++++++++++++- 1 file changed, 220 insertions(+), 2 deletions(-)
tests/intel/xe_multi_gpusvm.c +220 -2
@@ -34,8 +34,13 @@* SUBTEST: atomic-inc-gpu-op * Description: * This test does atomic operation in multi-gpu by executing atomic -* operation on GPU1 and then atomic operation on GPU2 using same -* adress +* operation on GPU1 and then atomic operation on GPU2 using same +* adress +* +* SUBTEST: coherency-multi-gpu +* Description: +* This test checks coherency in multi-gpu by writing from GPU0 +* reading from GPU1 and verify and repeating with CPU and both GPUs */ #define MAX_XE_REGIONS 8
@@ -94,6 +99,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)
@@ -265,6 +299,172 @@ gpu_mem_access(struct xe_svm_gpu_info *src_gpu,copy_src_dst (src_gpu, dst_gpu, eci); } +static void +coherency_test_multigpu (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci, +bool coh_fail_set, +bool prefetch_req) +{ +uint64_t addr; +uint32_t vm[2 ]; +uint32_t exec_queue[2 ]; +uint32_t batch_bo, batch1_bo[2 ]; +uint64_t batch_addr, batch1_addr[2 ]; +struct drm_xe_sync sync = {}; +volatile uint64_t *sync_addr; +int value =60 ; +uint64_t *data1; +void *copy_dst; + + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,0 ,1ull << gpu1->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + 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); + +store_dword_batch_init (gpu0->fd, vm[0 ], addr, &batch_bo, &batch_addr, value); + +/* Place destination in GPU0 local memory location to test */ +xe_vm_madvise (gpu0->fd, vm[0 ], addr,SZ_4K ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +/* prefetch full buffer for GPU0 */ +if (prefetch_req) { +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , addr,SZ_4K , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + } +free ((void *)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 ; + *sync_addr =0 ; + +/* Execute STORE command on GPU0 */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + +igt_assert_eq (*(uint64_t *)addr, value); + +/* Creating batch for GPU1 using addr as Src which have value from GPU0 */ +batch_init (gpu1->fd, vm[1 ], addr,to_user_pointer (copy_dst), +SZ_4K , &batch_bo, &batch_addr); + +/* Place destination in GPU1 local memory location to test */ +xe_vm_madvise (gpu1->fd, vm[1 ], addr,SZ_4K ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +/* prefetch full buffer for GPU1 */ +if (prefetch_req) { +xe_vm_prefetch_async (gpu1->fd, vm[1 ],0 ,0 , addr, +SZ_4K , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + } +free ((void *)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 ; + *sync_addr =0 ; + +/* Execute COPY command on GPU1 */ +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + +igt_assert_eq (*(uint64_t *)copy_dst, value); + +/* CPU writes 10, memset set bytes no integer hence memset fills 4 bytes with 0x0A */ +memset ((void *)(uintptr_t )addr,10 ,sizeof (int )); +igt_assert_eq (*(uint64_t *)addr,0x0A0A0A0A ); + +/* Coherency fail scenario */ +store_dword_batch_init (gpu0->fd, vm[0 ], addr, &batch1_bo[0 ], &batch1_addr[0 ], value +10 ); +store_dword_batch_init (gpu1->fd, vm[1 ], addr, &batch1_bo[1 ], &batch1_addr[1 ], value +20 ); + +if (coh_fail_set) { +igt_info ("coherency fail impl\n" ); + + sync_addr = (void *)((char *)batch1_addr[0 ] +SZ_4K ); + sync.addr =to_user_pointer ((uint64_t *)sync_addr); + sync.timeline_value =EXEC_SYNC_VAL ; + *sync_addr =0 ; + +/* Execute STORE command on GPU1 */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch1_addr[0 ], &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + + sync_addr = (void *)((char *)batch1_addr[1 ] +SZ_4K ); + sync.addr =to_user_pointer ((uint64_t *)sync_addr); + sync.timeline_value =EXEC_SYNC_VAL ; + *sync_addr =0 ; + +/* Execute STORE command on GPU2 */ +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch1_addr[1 ], &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + +igt_assert_f (*(uint64_t *)addr == (value +10 ), +"GPU2 has overwritten value at addr\n" ); + } + +/* CPU writes 11, memset set bytes no integer hence memset fills 4 bytes with 0x0B */ +memset ((void *)(uintptr_t )addr,11 ,sizeof (int )); +igt_assert_eq (*(uint64_t *)addr,0x0B0B0B0B ); + +munmap ((void *)batch_addr,BATCH_SIZE (gpu0->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo, batch_addr); +free (data1); + +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); +} + static void atomic_inc_op(struct xe_svm_gpu_info *gpu0, struct xe_svm_gpu_info *gpu1,
@@ -403,6 +603,19 @@ gpu_atomic_inc(struct xe_svm_gpu_info *src_gpu,atomic_inc_op (src_gpu, dst_gpu, eci, prefetch_req); } +static void +gpu_coherecy_test (struct xe_svm_gpu_info *src_gpu, +struct xe_svm_gpu_info *dst_gpu, +struct drm_xe_engine_class_instance *eci, +bool coh_fail, +bool prefetch_req) +{ +igt_assert (src_gpu); +igt_assert (dst_gpu); + +coherency_test_multigpu (src_gpu, dst_gpu, eci, coh_fail, prefetch_req); +} + igt_main {struct xe_svm_gpu_info gpus[MAX_XE_GPUS ];
@@ -442,6 +655,11 @@ igt_maingpu_atomic_inc (&gpus[0 ], &gpus[1 ], &eci,0 ); } + igt_subtest("coherency-multi-gpu") { +gpu_coherecy_test (&gpus[0 ], &gpus[1 ], &eci,0 ,1 ); +gpu_coherecy_test (&gpus[0 ], &gpus[1 ], &eci,1 ,0 ); + } + igt_fixture {int cnt;
Signature · 1 line
2.48.1
PATCH 4/7 tests/intel/xe_multi-gpusvm.c: 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 | 444 ++++++++++++++++++++++++++++++++++ 1 file changed, 444 insertions(+)
tests/intel/xe_multi_gpusvm.c +444 -0
@@ -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"
@@ -41,6 +43,17 @@* Description: * This test checks coherency in multi-gpu by writing from GPU0 * reading from GPU1 and verify and repeating with CPU and both GPUs +* +* SUBTEST: conflicting-madvise-gpu +* Description: +* This test checks conflicting madvise by allocating shared buffer +* prefetches from both and checks for migration conflicts +* This test checks conflicting madvise +* +* SUBTEST: latency-multi-gpu +* Description: +* This test measures and compares latency and bandwidth for buffer access +* from CPU, local GPU, and remote GPU */ #define MAX_XE_REGIONS 8
@@ -72,6 +85,11 @@ struct test_exec_data {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)
@@ -465,6 +483,399 @@ coherency_test_multigpu(struct xe_svm_gpu_info *gpu0,xe_vm_destroy (gpu1->fd, vm[1 ]); } +static void +latency_test_multigpu (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci, +bool remote_copy, +bool prefetch_req) +{ +uint64_t addr; +uint32_t vm[2 ]; +uint32_t exec_queue[2 ]; +uint32_t batch_bo; +uint8_t *copy_dst; +uint64_t batch_addr; +struct drm_xe_sync sync = {}; +volatile uint64_t *sync_addr; +int value =60 ; +int shared_val[4 ]; +struct test_exec_data *data; +struct timespec t_start, t_end; +double cpu_latency, gpu1_latency, gpu2_latency; +double cpu_bw, gpu1_bw, gpu2_bw; + + + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,0 ,1ull << gpu1->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + 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); + +store_dword_batch_init (gpu0->fd, vm[0 ], addr, &batch_bo, &batch_addr, value); + +/* Measure GPU0 access latency/bandwidth */ +clock_gettime (CLOCK_MONOTONIC , &t_start); + +/* GPU0 access */ +xe_vm_madvise (gpu0->fd, vm[0 ], addr,SZ_4K ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +if (prefetch_req) { +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , addr,SZ_4K , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + } +free ((void *)sync_addr); + +clock_gettime (CLOCK_MONOTONIC , &t_end); + gpu1_latency =time_diff (&t_start, &t_end); + gpu1_bw =COPY_SIZE / gpu1_latency / (1024 *1024 );// MB/s + + sync_addr = (void *)((char *)batch_addr +SZ_4K ); + sync.addr =to_user_pointer ((uint64_t *)sync_addr); + sync.timeline_value =EXEC_SYNC_VAL ; + *sync_addr =0 ; + +/* Execute STORE command on GPU0 */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + +memcpy (shared_val, (void *)addr,4 ); +igt_assert_eq (shared_val[0 ], value); + +/* CPU writes 10, memset set bytes no integer hence memset fills 4 bytes with 0x0A */ +memset ((void *)(uintptr_t )addr,10 ,sizeof (int )); +memcpy (shared_val, (void *)(uintptr_t )addr,sizeof (shared_val)); +igt_assert_eq (shared_val[0 ],0x0A0A0A0A ); + + *(uint64_t *)addr =50 ; + +if (remote_copy) { +igt_info ("creating batch for COPY_CMD on GPU1\n" ); +batch_init (gpu1->fd, vm[1 ], addr,to_user_pointer (copy_dst), +SZ_4K , &batch_bo, &batch_addr); + } +else { +igt_info ("creating batch for STORE_CMD on GPU1\n" ); +store_dword_batch_init (gpu1->fd, vm[1 ], addr, &batch_bo, &batch_addr, value +10 ); + } + +/* Measure GPU1 access latency/bandwidth */ +clock_gettime (CLOCK_MONOTONIC , &t_start); + +/* GPU1 access */ +xe_vm_madvise (gpu1->fd, vm[1 ], addr,SZ_4K ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +if (prefetch_req) { +xe_vm_prefetch_async (gpu1->fd, vm[1 ],0 ,0 , addr, +SZ_4K , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + } +free ((void *)sync_addr); + +clock_gettime (CLOCK_MONOTONIC , &t_end); + gpu2_latency =time_diff (&t_start, &t_end); + gpu2_bw =COPY_SIZE / gpu2_latency / (1024 *1024 );// MB/s + + sync_addr = (void *)((char *)batch_addr +SZ_4K ); + sync.addr =to_user_pointer ((uint64_t *)sync_addr); + sync.timeline_value =EXEC_SYNC_VAL ; + *sync_addr =0 ; + +/* Execute COPY/STORE command on GPU1 */ +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + +if (!remote_copy) +igt_assert_eq (*(uint64_t *)addr, value +10 ); +else +igt_assert_eq (*(uint64_t *)copy_dst,50 ); + +/* CPU writes 11, memset set bytes no integer hence memset fills 4 bytes with 0x0B */ +/* Measure CPU access latency/bandwidth */ +clock_gettime (CLOCK_MONOTONIC , &t_start); +memset ((void *)(uintptr_t )addr,11 ,sizeof (int )); +memcpy (shared_val, (void *)(uintptr_t )addr,sizeof (shared_val)); +clock_gettime (CLOCK_MONOTONIC , &t_end); + cpu_latency =time_diff (&t_start, &t_end); + cpu_bw =COPY_SIZE / cpu_latency / (1024 *1024 );// MB/s + +igt_assert_eq (shared_val[0 ],0x0B0B0B0B ); + +/* Print results */ +igt_info ("CPU: Latency %.6f s, Bandwidth %.2f MB/s\n" , cpu_latency, cpu_bw); +igt_info ("GPU1: Latency %.6f s, Bandwidth %.2f MB/s\n" , gpu1_latency, gpu1_bw); +igt_info ("GPU2: Latency %.6f s, Bandwidth %.2f MB/s\n" , gpu2_latency, gpu2_bw); + +munmap ((void *)batch_addr,BATCH_SIZE (gpu0->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo, batch_addr); +batch_fini (gpu1->fd, vm[1 ], batch_bo, batch_addr); +free (data); +free (copy_dst); + +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); +} + +int mem_region (int fd) +{ +uint64_t regions =all_memory_regions (fd); +uint64_t region =-1 ; + +xe_for_each_mem_region (fd, regions, region) { +if (XE_IS_SYSMEM_MEMORY_REGION (fd, region)) { +struct drm_xe_mem_region *mem_region = +xe_mem_region (fd,1ull << (region)); + region = mem_region->instance; +printf ("region instance :%d region name :%s\n" , region,xe_region_name (region)); +break ; + } + } + +printf ("returning region :%d\n" , region); +return region; +} + +#define XE_BO_FLAG_SYSTEM BIT(1) +#define XE_BO_FLAG_CPU_ADDR_MIRROR BIT(24) + +static void +conflicting_madvise (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci) +{ + +uint32_t vm[3 ]; +uint32_t exec_queue[3 ]; +uint32_t batch_bo[3 ]; +uint64_t batch_addr[3 ], svm_addr; +struct test_exec_data *data; +volatile uint64_t sync_val1 =0 ; +volatile uint64_t sync_val2 =0 ; + +// Define sync structures +struct drm_xe_sync sync1 = { + .type =DRM_XE_SYNC_TYPE_USER_FENCE , + .flags =DRM_XE_SYNC_FLAG_SIGNAL , + .addr = (uint64_t )(uintptr_t )&sync_val1,// user-space address + .timeline_value =USER_FENCE_VALUE ,// or desired fence value + }; + +struct drm_xe_sync sync2 = { + .type =DRM_XE_SYNC_TYPE_USER_FENCE , + .flags =DRM_XE_SYNC_FLAG_SIGNAL , + .addr = (uint64_t )(uintptr_t )&sync_val2, + .timeline_value =USER_FENCE_VALUE , + }; + +#define QUARTER_SEC (NSEC_PER_SEC / 4) +int64_t timeout =QUARTER_SEC ; + data =aligned_alloc (SZ_64M ,SZ_64M ); +igt_assert (data); + + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu1->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + svm_addr =to_user_pointer (data); + +xe_vm_madvise (gpu0->fd, vm[0 ], svm_addr,COPY_SIZE ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , +DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM ,0 ,0 ); + + *(uint64_t *)svm_addr =50 ; + +atomic_batch_init (gpu0->fd, vm[0 ], svm_addr, &batch_bo[0 ], &batch_addr[0 ]); +atomic_batch_init (gpu1->fd, vm[1 ], svm_addr, &batch_bo[1 ], &batch_addr[1 ]); + +#if 0 +xe_vm_madvise (gpu0->fd, vm[0 ], svm_addr,COPY_SIZE ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , +DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM ,0 ,0 ); +xe_vm_madvise (gpu1->fd, vm[0 ], svm_addr,COPY_SIZE ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , +DRM_XE_PREFERRED_LOC_DEFAULT_SYSTEM ,0 ,0 ); +#endif + +#if 1 +xe_vm_madvise (gpu0->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu0->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); + +xe_vm_madvise (gpu1->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu1->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); +#endif + +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , svm_addr, +BATCH_SIZE (gpu0->fd), &sync1,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); + +xe_vm_prefetch_async (gpu1->fd, vm[0 ],0 ,0 , svm_addr, +BATCH_SIZE (gpu1->fd), &sync2,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (sync_val1 !=BIND_SYNC_VAL ) +__xe_wait_ufence (gpu0->fd, (uint64_t *)&sync1,BIND_SYNC_VAL , exec_queue[0 ], + &timeout); +if (sync_val2 !=BIND_SYNC_VAL ) +__xe_wait_ufence (gpu1->fd, (uint64_t *)&sync2,BIND_SYNC_VAL , exec_queue[1 ], + &timeout); + +/* Executing ATOMIC_INC on GPU0. */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr[0 ], &sync1,1 ); +if (sync_val1 !=EXEC_SYNC_VAL ) +__xe_wait_ufence (gpu0->fd, (uint64_t *)sync_val1,EXEC_SYNC_VAL , exec_queue[0 ], + &timeout); + + +} + +static void +conflict_test_multigpu (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci) +{ +uint32_t vm[2 ]; +uint32_t exec_queue[2 ]; +uint32_t batch_bo, batch1_bo; +void *copy_src, *copy_dst; +uint64_t batch_addr, svm_addr; +int region; +struct drm_xe_sync sync = {}; +volatile uint64_t *sync_addr; +void *batch, *cpu_ptr; +struct xe_svm_gpu_info gpu_mem[1 ]; + +#if 1 + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,0 ,1ull << gpu1->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + region =mem_region (gpu0->fd); +int render_fd; + render_fd =drm_open_driver (DRIVER_XE ); +printf ("render_fd :%d gpu0->fd :%d gpu1->fd :%d\n" , + render_fd, gpu0->fd, gpu0->fd); +// printf("region is :%d\n", region); +//batch_bo = xe_bo_create(render_fd, 0, BATCH_SIZE(render_fd), system_memory(render_fd), XE_BO_FLAG_SYSTEM); + batch_bo =xe_bo_create (gpu0->fd, vm[0 ],BATCH_SIZE (gpu0->fd), region,XE_BO_FLAG_SYSTEM ); + batch =xe_bo_map (gpu0->fd, batch_bo,BATCH_SIZE (gpu0->fd)); +//batch = xe_bo_map(render_fd, batch_bo, BATCH_SIZE(render_fd)); + render_fd =open ("/dev/dri/card0" ,O_RDWR ); +if (render_fd <=0 ) { +perror ("open error for card0" ); +// handle error + } +//render_fd = drm_open_driver(DRIVER_XE); +printf ("render_fd :%d gpu0->fd :%d gpu1->fd :%d\n" , + render_fd, gpu0->fd, gpu1->fd); +printf ("region is :%d\n" , region); +//batch_bo = xe_bo_create(render_fd, 0, COPY_SIZE, region, XE_BO_FLAG_SYSTEM); + batch_bo =xe_bo_create (gpu0->fd,0 ,BATCH_SIZE (gpu0->fd), region,XE_BO_FLAG_SYSTEM ); + batch =xe_bo_map (gpu0->fd, batch_bo,BATCH_SIZE (gpu0->fd)); +//batch = xe_bo_map(render_fd, batch_bo, COPY_SIZE); +igt_assert (batch); + + svm_addr =to_user_pointer (batch); + +igt_info ("Calling first bind\n" ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ], batch_bo,0 , svm_addr,BATCH_SIZE (gpu0->fd),0 ); +igt_info ("Calling second bind\n" ); +//xe_vm_bind_lr_sync(gpu1->fd, vm[1], batch_bo, 0, svm_addr, BATCH_SIZE(gpu1->fd), 0); +//xe_vm_bind_lr_sync(gpu1->fd, vm[0], batch_bo, 0, svm_addr, BATCH_SIZE(gpu1->fd), 0); + +xe_vm_madvise (gpu0->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu0->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + +xe_vm_madvise (gpu1->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu1->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); +xe_vm_madvise (gpu0->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu1->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); +#if 0 +xe_vm_madvise (gpu1->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu1->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); +#endif + +printf ("1st Prefetch calling\n" ); +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , svm_addr, +BATCH_SIZE (gpu0->fd), &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); + +printf ("2nd Prefetch calling\n" ); +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , svm_addr, +BATCH_SIZE (gpu1->fd), &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); + +munmap ((void *)batch_addr,BATCH_SIZE (gpu0->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo, batch_addr); +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +batch_fini (gpu1->fd, vm[1 ], batch_bo, batch_addr); +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); +drm_close_driver (render_fd); +#endif +} + static void atomic_inc_op(struct xe_svm_gpu_info *gpu0, struct xe_svm_gpu_info *gpu1,
@@ -616,6 +1027,31 @@ gpu_coherecy_test(struct xe_svm_gpu_info *src_gpu,coherency_test_multigpu (src_gpu, dst_gpu, eci, coh_fail, prefetch_req); } +static void +gpu_conflict_madvise_test (struct xe_svm_gpu_info *src_gpu, +struct xe_svm_gpu_info *dst_gpu, +struct drm_xe_engine_class_instance *eci) +{ +igt_assert (src_gpu); +igt_assert (dst_gpu); + +//conflict_test_multigpu(src_gpu, dst_gpu, eci); +conflicting_madvise (src_gpu, dst_gpu, eci); +} + +static void +gpu_latency_test (struct xe_svm_gpu_info *src_gpu, +struct xe_svm_gpu_info *dst_gpu, +struct drm_xe_engine_class_instance *eci, +bool remote_copy, +bool prefetch_req) +{ +igt_assert (src_gpu); +igt_assert (dst_gpu); + +latency_test_multigpu (src_gpu, dst_gpu, eci, remote_copy, prefetch_req); +} + igt_main {struct xe_svm_gpu_info gpus[MAX_XE_GPUS ];
@@ -660,6 +1096,14 @@ igt_maingpu_coherecy_test (&gpus[0 ], &gpus[1 ], &eci,1 ,0 ); } + igt_subtest("conflicting-madvise-gpu") +gpu_conflict_madvise_test (&gpus[0 ], &gpus[1 ], &eci); + + igt_subtest("latency-multi-gpu") { +gpu_latency_test (&gpus[0 ], &gpus[1 ], &eci,1 ,1 ); +gpu_latency_test (&gpus[0 ], &gpus[1 ], &eci,0 ,0 ); + } + igt_fixture {int cnt;
Signature · 1 line
2.48.1
PATCH 5/7 tests/intel/xe_multi-gpusvm.c: 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 | 226 ++++++++++++++++++++++++++++++++++ 1 file changed, 226 insertions(+)
tests/intel/xe_multi_gpusvm.c +226 -0
@@ -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"
@@ -54,6 +55,11 @@* Description: * This test measures and compares latency and bandwidth for buffer access * from CPU, local GPU, and remote GPU +* +* SUBTEST: pagefault-multi-gpu +* Description: +* This test intentionally triggers page faults by accessing unmapped SVM +* regions from both GPUs */ #define MAX_XE_REGIONS 8
@@ -661,6 +667,212 @@ latency_test_multigpu(struct xe_svm_gpu_info *gpu0,xe_vm_destroy (gpu1->fd, vm[1 ]); } +static void +pagefault_test_multigpu (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci) +{ +uint64_t addr; +uint32_t vm[2 ]; +uint32_t exec_queue[2 ]; +uint32_t batch_bo; +uint8_t *copy_dst; +uint64_t batch_addr; +struct drm_xe_sync sync = {}; +volatile uint64_t *sync_addr; +int value =60 , pf_count_1, pf_count_2; +int pf_count_madvise_1, pf_count_madvise_2; +int shared_val[4 ]; +struct test_exec_data *data; +const char *pf_count_stat ="svm_pagefault_count" ; + + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,0 ,1ull << gpu1->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + data =aligned_alloc (xe_get_default_alignment (gpu0->fd),SZ_64M ); +igt_assert (data); + data[0 ].vm_sync =0 ; + addr =to_user_pointer (data); + + copy_dst =aligned_alloc (xe_get_default_alignment (gpu1->fd),SZ_64M ); +igt_assert (copy_dst); + + pf_count_1 =xe_gt_stats_get_count (gpu0->fd, eci->gt_id, pf_count_stat); +igt_info ("pf_count before trigerring xe_exec on gpu1 without madvise :%d\n" , + pf_count_1); + +/* checking pagefault count for gpu1 */ +store_dword_batch_init (gpu0->fd, vm[0 ], addr, &batch_bo, &batch_addr, 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + sync_addr = (void *)((char *)batch_addr +SZ_4K ); + sync.addr =to_user_pointer ((uint64_t *)sync_addr); + sync.timeline_value =EXEC_SYNC_VAL ; + *sync_addr =0 ; + +/* Execute STORE command on GPU1 */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + + pf_count_2 =xe_gt_stats_get_count (gpu0->fd, eci->gt_id, pf_count_stat); +igt_info ("pf_count after trigerring xe_exec on gpu1 without madvise :%d\n" , + pf_count_2 - pf_count_1); + +memcpy (shared_val, (void *)addr,4 ); +igt_assert_eq (shared_val[0 ], value); + +/* CPU writes 10, memset set bytes no integer hence memset fills 4 bytes with 0x0A */ +memset ((void *)(uintptr_t )addr,10 ,sizeof (int )); +memcpy (shared_val, (void *)(uintptr_t )addr,sizeof (shared_val)); +igt_assert_eq (shared_val[0 ],0x0A0A0A0A ); + + pf_count_1 =xe_gt_stats_get_count (gpu1->fd, eci->gt_id, pf_count_stat); +igt_info ("pf_count before trigerring xe_exec on gpu2 without madvise :%d\n" , + pf_count_1); + +/* checking pagefault count for gpu2 */ +store_dword_batch_init (gpu1->fd, vm[1 ], addr, &batch_bo, &batch_addr, value +10 ); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + sync_addr = (void *)((char *)batch_addr +SZ_4K ); + sync.addr =to_user_pointer ((uint64_t *)sync_addr); + sync.timeline_value =EXEC_SYNC_VAL ; + *sync_addr =0 ; + +/* Execute STORE command on GPU2 */ +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + + pf_count_2 =xe_gt_stats_get_count (gpu1->fd, eci->gt_id, pf_count_stat); +igt_info ("pf_count after trigerring xe_exec on gpu2 without madvise :%d\n" , + pf_count_2 - pf_count_1); + +memcpy (shared_val, (void *)addr,4 ); +igt_assert_eq (shared_val[0 ], value +10 ); + + pf_count_madvise_1 =xe_gt_stats_get_count (gpu0->fd, eci->gt_id, pf_count_stat); +igt_info ("pf_count before madvise on gpu1 :%d\n" , pf_count_madvise_1); + +store_dword_batch_init (gpu0->fd, vm[0 ], addr, &batch_bo, &batch_addr, value +10 ); + +/* Place destination in an optionally remote location to test */ +xe_vm_madvise (gpu0->fd, vm[0 ], addr,COPY_SIZE ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +/* Prefetch half of destination */ +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , addr,COPY_SIZE /2 , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); + +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); +free ((void *)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 ; + *sync_addr =0 ; + +/* Execute STORE command on GPU1 */ +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); + + pf_count_madvise_2 =xe_gt_stats_get_count (gpu0->fd, eci->gt_id, pf_count_stat); +if (pf_count_madvise_2 != pf_count_madvise_1) +igt_warn ("pf_count_madvise_2(%d) != pf_count_madvise_1(%d)\n" , + pf_count_madvise_2, pf_count_madvise_1); + +memcpy (shared_val, (void *)addr,4 ); +igt_assert_eq (shared_val[0 ], value +10 ); + +/* CPU writes 10, memset set bytes no integer hence memset fills 4 bytes with 0x0A */ +memset ((void *)(uintptr_t )addr,10 ,sizeof (int )); +memcpy (shared_val, (void *)(uintptr_t )addr,sizeof (shared_val)); +igt_assert_eq (shared_val[0 ],0x0A0A0A0A ); + +store_dword_batch_init (gpu1->fd, vm[1 ], addr, &batch_bo, &batch_addr, value +10 ); + + 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 =BIND_SYNC_VAL ; + *sync_addr =0 ; + +/* Prefetch half of destination */ +xe_vm_prefetch_async (gpu1->fd, vm[1 ],0 ,0 , addr, +COPY_SIZE /2 , &sync,1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); +if (*sync_addr !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,BIND_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); +free ((void *)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 ; + *sync_addr =0 ; + +/* Execute STORE command on GPU2 */ +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch_addr, &sync,1 ); +if (*sync_addr !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + +memcpy (shared_val, (void *)addr,4 ); +igt_assert_eq (shared_val[0 ], value +10 ); + +/* CPU writes 11, memset set bytes no integer hence memset fills 4 bytes with 0x0B */ +memset ((void *)(uintptr_t )addr,11 ,sizeof (int )); +memcpy (shared_val, (void *)(uintptr_t )addr,sizeof (shared_val)); +igt_assert_eq (shared_val[0 ],0x0B0B0B0B ); + +munmap ((void *)batch_addr,BATCH_SIZE (gpu0->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo, batch_addr); +free (data); + +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); +} +int mem_region (int fd) {uint64_t regions =all_memory_regions (fd);
@@ -1052,6 +1264,17 @@ gpu_latency_test(struct xe_svm_gpu_info *src_gpu,latency_test_multigpu (src_gpu, dst_gpu, eci, remote_copy, prefetch_req); } +static void +gpu_pagefault_test (struct xe_svm_gpu_info *src_gpu, +struct xe_svm_gpu_info *dst_gpu, +struct drm_xe_engine_class_instance *eci) +{ +igt_assert (src_gpu); +igt_assert (dst_gpu); + +pagefault_test_multigpu (src_gpu, dst_gpu, eci); +} + igt_main {struct xe_svm_gpu_info gpus[MAX_XE_GPUS ];
@@ -1104,6 +1327,9 @@ igt_maingpu_latency_test (&gpus[0 ], &gpus[1 ], &eci,0 ,0 ); } + igt_subtest("pagefault-multi-gpu") +gpu_pagefault_test (&gpus[0 ], &gpus[1 ], &eci); + igt_fixture {int cnt;
Signature · 1 line
2.48.1
PATCH 6/7 tests/intel/xe_multi-gpusvm.c: 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 | 180 +++++++++++++++++++++++++++++++++- 1 file changed, 177 insertions(+), 3 deletions(-)
tests/intel/xe_multi_gpusvm.c +177 -3
@@ -49,7 +49,6 @@* Description: * This test checks conflicting madvise by allocating shared buffer * prefetches from both and checks for migration conflicts -* This test checks conflicting madvise * * SUBTEST: latency-multi-gpu * Description:
@@ -60,6 +59,11 @@* Description: * This test intentionally triggers page faults by accessing unmapped SVM * regions from both GPUs +* +* SUBTEST: concurrent-access-multi-gpu +* Description: +* This tests aunches simultaneous workloads on both GPUs accessing the +* same SVM buffer synchronizes with fences, and verifies data integrity */ #define MAX_XE_REGIONS 8
@@ -908,6 +912,7 @@ conflicting_madvise(struct xe_svm_gpu_info *gpu0,struct test_exec_data *data;volatile uint64_t sync_val1 =0 ;volatile uint64_t sync_val2 =0 ; +volatile uint64_t *sync_addr;// Define sync structures struct drm_xe_sync sync1 = {
@@ -966,6 +971,15 @@ conflicting_madvise(struct xe_svm_gpu_info *gpu0,DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , gpu0->fd, 0, gpu0->vram_regions[0]);#endif +#if 0 +xe_vm_madvise (gpu0->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu0->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + +xe_vm_madvise (gpu1->fd, vm[0 ], svm_addr,BATCH_SIZE (gpu1->fd),0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); +#endif xe_vm_prefetch_async(gpu0->fd, vm[0], 0, 0, svm_addr, BATCH_SIZE(gpu0->fd), &sync1, 1,
@@ -981,13 +995,31 @@ conflicting_madvise(struct xe_svm_gpu_info *gpu0,__xe_wait_ufence (gpu1->fd, (uint64_t *)&sync2,BIND_SYNC_VAL , exec_queue[1 ], &timeout); + sync_addr = (void *)((char *)batch_addr[0 ] +SZ_4K ); + sync1.addr =to_user_pointer ((uint64_t *)sync_addr); +//sync.timeline_value = EXEC_SYNC_VAL; + *sync_addr =0 ; +/* Executing ATOMIC_INC on GPU0. */ xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr[0 ], &sync1,1 ); -if (sync_val1 !=EXEC_SYNC_VAL ) -__xe_wait_ufence (gpu0->fd, (uint64_t *)sync_val1,EXEC_SYNC_VAL , exec_queue[0 ], +if (*sync_addr !=EXEC_SYNC_VAL ) +__xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr,EXEC_SYNC_VAL , exec_queue[0 ], &timeout); +igt_assert_eq (*(uint64_t *)svm_addr,51 ); +munmap ((void *)batch_addr[0 ],BATCH_SIZE (gpu0->fd)); +munmap ((void *)batch_addr[1 ],BATCH_SIZE (gpu1->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo[0 ], batch_addr[0 ]); +batch_fini (gpu1->fd, vm[1 ], batch_bo[1 ], batch_addr[1 ]); +free (data); +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); } static void
@@ -1214,6 +1246,131 @@ atomic_inc_op(struct xe_svm_gpu_info *gpu0,xe_vm_destroy (gpu1->fd, vm[1 ]); } +static void +multigpu_access_test (struct xe_svm_gpu_info *gpu0, +struct xe_svm_gpu_info *gpu1, +struct drm_xe_engine_class_instance *eci, +bool no_prefetch) +{ +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 ] = {}; +volatile uint64_t *sync_addr[2 ]; +volatile uint32_t *shared_val; +#define QUARTER_SEC (NSEC_PER_SEC / 4) +int64_t timeout =QUARTER_SEC ; + + vm[0 ] =xe_vm_create (gpu0->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[0 ] =xe_exec_queue_create (gpu0->fd, vm[0 ], eci,0 ); +xe_vm_bind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,0 ,1ull << gpu0->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + vm[1 ] =xe_vm_create (gpu1->fd,DRM_XE_VM_CREATE_FLAG_LR_MODE |DRM_XE_VM_CREATE_FLAG_FAULT_MODE ,0 ); + exec_queue[1 ] =xe_exec_queue_create (gpu1->fd, vm[1 ], eci,0 ); +xe_vm_bind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,0 ,1ull << gpu1->va_bits,DRM_XE_VM_BIND_FLAG_CPU_ADDR_MIRROR ); + + data =aligned_alloc (xe_get_default_alignment (gpu0->fd),SZ_64M ); +igt_assert (data); + data[0 ].vm_sync =0 ; + addr =to_user_pointer (data); + + shared_val = (volatile uint32_t *)addr; + *shared_val =ATOMIC_OP_VAL -1 ; + +atomic_batch_init (gpu0->fd, vm[0 ], addr, &batch_bo[0 ], &batch_addr[0 ]); + *shared_val =ATOMIC_OP_VAL -2 ; +atomic_batch_init (gpu1->fd, vm[1 ], addr, &batch_bo[1 ], &batch_addr[1 ]); + +/* Place destination in an optionally remote location to test */ +xe_vm_madvise (gpu0->fd, vm[0 ], addr,COPY_SIZE ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu0->fd,0 , gpu0->vram_regions[0 ]); + +xe_vm_madvise (gpu1->fd, vm[1 ], addr,COPY_SIZE ,0 , +DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC , + gpu1->fd,0 , gpu1->vram_regions[0 ]); + + sync_addr[0 ] =malloc (sizeof (*sync_addr)); + sync_addr[1 ] =malloc (sizeof (*sync_addr)); +igt_assert (!!sync_addr[0 ]); +igt_assert (!!sync_addr[1 ]); + + 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 =BIND_SYNC_VAL ; + 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 =BIND_SYNC_VAL ; + *sync_addr[0 ] =0 ; + *sync_addr[1 ] =0 ; + +if (!no_prefetch) { +xe_vm_prefetch_async (gpu0->fd, vm[0 ],0 ,0 , addr, +COPY_SIZE /2 , &sync[0 ],1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); + +xe_vm_prefetch_async (gpu1->fd, vm[1 ],0 ,0 , addr, +COPY_SIZE /2 , &sync[1 ],1 , +DRM_XE_CONSULT_MEM_ADVISE_PREF_LOC ); + +if (*sync_addr[0 ] !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr[0 ],BIND_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); +free ((void *)sync_addr[0 ]); +if (*sync_addr[1 ] !=BIND_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr[1 ],BIND_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); +free ((void *)sync_addr[1 ]); + } + +if (no_prefetch) { +free ((void *)sync_addr[0 ]); +free ((void *)sync_addr[1 ]); + } + +for (int i =0 ; i <100 ; 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 ; + *sync_addr[0 ] =0 ; + *sync_addr[1 ] =0 ; + +xe_exec_sync (gpu0->fd, exec_queue[0 ], batch_addr[0 ], &sync[0 ],1 ); +if (*sync_addr[0 ] !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu0->fd, (uint64_t *)sync_addr[0 ],EXEC_SYNC_VAL , exec_queue[0 ], +NSEC_PER_SEC *10 ); +xe_exec_sync (gpu1->fd, exec_queue[1 ], batch_addr[1 ], &sync[1 ],1 ); +if (*sync_addr[1 ] !=EXEC_SYNC_VAL ) +xe_wait_ufence (gpu1->fd, (uint64_t *)sync_addr[1 ],EXEC_SYNC_VAL , exec_queue[1 ], +NSEC_PER_SEC *10 ); + } + +igt_assert_eq (*(uint64_t *)addr,254 ); + +munmap ((void *)batch_addr[0 ],BATCH_SIZE (gpu0->fd)); +munmap ((void *)batch_addr[1 ],BATCH_SIZE (gpu0->fd)); +batch_fini (gpu0->fd, vm[0 ], batch_bo[0 ], batch_addr[0 ]); +batch_fini (gpu1->fd, vm[1 ], batch_bo[1 ], batch_addr[1 ]); +free (data); + +xe_vm_unbind_lr_sync (gpu0->fd, vm[0 ],0 ,0 ,1ull << gpu0->va_bits); +xe_exec_queue_destroy (gpu0->fd, exec_queue[0 ]); +xe_vm_destroy (gpu0->fd, vm[0 ]); + +xe_vm_unbind_lr_sync (gpu1->fd, vm[1 ],0 ,0 ,1ull << gpu1->va_bits); +xe_exec_queue_destroy (gpu1->fd, exec_queue[1 ]); +xe_vm_destroy (gpu1->fd, vm[1 ]); +} + static void gpu_atomic_inc(struct xe_svm_gpu_info *src_gpu, struct xe_svm_gpu_info *dst_gpu,
@@ -1275,6 +1432,18 @@ gpu_pagefault_test(struct xe_svm_gpu_info *src_gpu,pagefault_test_multigpu (src_gpu, dst_gpu, eci); } +static void +gpu_access_test (struct xe_svm_gpu_info *src_gpu, +struct xe_svm_gpu_info *dst_gpu, +struct drm_xe_engine_class_instance *eci, +bool no_prefetch) +{ +igt_assert (src_gpu); +igt_assert (dst_gpu); + +multigpu_access_test (src_gpu, dst_gpu, eci, no_prefetch); +} + igt_main {struct xe_svm_gpu_info gpus[MAX_XE_GPUS ];
@@ -1330,6 +1499,11 @@ igt_main igt_subtest("pagefault-multi-gpu")gpu_pagefault_test (&gpus[0 ], &gpus[1 ], &eci); + igt_subtest("concurrent-access-multi-gpu") { +gpu_access_test (&gpus[0 ], &gpus[1 ], &eci,0 ); +gpu_access_test (&gpus[0 ], &gpus[1 ], &eci,1 ); + } + igt_fixture {int cnt;
Signature · 1 line
2.48.1