[igt-dev] [PATCH i-g-t v3 4/6] tests/xe: handle small-bar systems
Souza, Jose
jose.souza at intel.com
Sat Jul 15 21:20:44 UTC 2023
On Fri, 2023-07-14 at 10:01 -0700, José Roberto de Souza wrote:
> On Fri, 2023-07-14 at 15:42 +0100, Matthew Auld wrote:
> > Convert all the existing tests that require CPU access.
> >
>
> Missing conversion in test_bad_flags(), test_bad_extensions(), test_bad_object(), test_with_one_bo_two_files(), test_reimport_close_race(),
> thread_fn_export_vs_close(), test_llseek_size(), test_llseek_bad().
>
> The mmaps tests are expected to fail but not because region is not cpu mmaped.
> For the prime_self_import test it is also good to require visible vram even if the test don't do any operation with CPU, in real world applications
> you need to give applications the flexibility to access it in CPU as well.
>
>
> > v2:
> > - Split out the lib changes
> > - Prefer SZ_256M and SZ_1G in xe_evict
> > - Simplify and fix the bo_flags handling in test_exec
> > v3:
> > - Small fix in xe_evict conversion (missing system_memory(fd))
> >
> > Signed-off-by: Matthew Auld <matthew.auld at intel.com>
> > Cc: José Roberto de Souza <jose.souza at intel.com>
> > Cc: Kamil Konieczny <kamil.konieczny at linux.intel.com>
> > Cc: Gwan-gyeong Mun <gwan-gyeong.mun at intel.com>
> > ---
> > tests/xe/xe_dma_buf_sync.c | 3 ++-
> > tests/xe/xe_evict.c | 34 +++++++++++++++++++++------------
> > tests/xe/xe_exec_balancer.c | 6 +++---
> > tests/xe/xe_exec_basic.c | 17 ++++++++---------
> > tests/xe/xe_exec_compute_mode.c | 4 ++--
> > tests/xe/xe_exec_fault_mode.c | 12 ++++++++----
> > tests/xe/xe_exec_reset.c | 13 ++++++++-----
> > tests/xe/xe_exec_store.c | 6 ++++--
> > tests/xe/xe_exec_threads.c | 9 ++++++---
> > tests/xe/xe_guc_pc.c | 3 ++-
> > tests/xe/xe_mmap.c | 4 ++--
> > tests/xe/xe_pm.c | 3 ++-
> > tests/xe/xe_prime_self_import.c | 8 ++++----
> > tests/xe/xe_vm.c | 23 +++++++++++++++-------
> > 14 files changed, 89 insertions(+), 56 deletions(-)
> >
> > diff --git a/tests/xe/xe_dma_buf_sync.c b/tests/xe/xe_dma_buf_sync.c
> > index c08f8ac18..4e76d85ab 100644
> > --- a/tests/xe/xe_dma_buf_sync.c
> > +++ b/tests/xe/xe_dma_buf_sync.c
> > @@ -120,7 +120,8 @@ test_export_dma_buf(struct drm_xe_engine_class_instance *hwe0,
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd[0]),
> > xe_get_default_alignment(fd[0]));
> > for (i = 0; i < n_bo; ++i) {
> > - bo[i] = xe_bo_create(fd[0], hwe0->gt_id, 0, bo_size);
> > + bo[i] = xe_bo_create_flags(fd[0], 0, bo_size,
> > + visible_vram_if_possible(fd[0], hwe0->gt_id));
> > dma_buf_fd[i] = prime_handle_to_fd(fd[0], bo[i]);
> > import_bo[i] = prime_fd_to_handle(fd[1], dma_buf_fd[i]);
> >
> > diff --git a/tests/xe/xe_evict.c b/tests/xe/xe_evict.c
> > index 1a70f1b45..c44cb80dc 100644
> > --- a/tests/xe/xe_evict.c
> > +++ b/tests/xe/xe_evict.c
> > @@ -97,15 +97,17 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
> > i < n_execs / 8 ? 0 : vm;
> >
> > if (flags & MULTI_VM) {
> > - __bo = bo[i] = xe_bo_create(fd, eci->gt_id, 0,
> > - bo_size);
> > + __bo = bo[i] = xe_bo_create_flags(fd, 0,
> > + bo_size,
> > + visible_vram_memory(fd, eci->gt_id));
> > } else if (flags & THREADED) {
> > - __bo = bo[i] = xe_bo_create(fd, eci->gt_id, vm,
> > - bo_size);
> > + __bo = bo[i] = xe_bo_create_flags(fd, vm,
> > + bo_size,
> > + visible_vram_memory(fd, eci->gt_id));
> > } else {
> > __bo = bo[i] = xe_bo_create_flags(fd, _vm,
> > bo_size,
> > - vram_memory(fd, eci->gt_id) |
> > + visible_vram_memory(fd, eci->gt_id) |
> > system_memory(fd));
> > }
> > } else {
> > @@ -278,15 +280,17 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
> > i < n_execs / 8 ? 0 : vm;
> >
> > if (flags & MULTI_VM) {
> > - __bo = bo[i] = xe_bo_create(fd, eci->gt_id,
> > - 0, bo_size);
> > + __bo = bo[i] = xe_bo_create_flags(fd, 0,
> > + bo_size,
> > + visible_vram_memory(fd, eci->gt_id));
> > } else if (flags & THREADED) {
> > - __bo = bo[i] = xe_bo_create(fd, eci->gt_id,
> > - vm, bo_size);
> > + __bo = bo[i] = xe_bo_create_flags(fd, vm,
> > + bo_size,
> > + visible_vram_memory(fd, eci->gt_id));
> > } else {
> > __bo = bo[i] = xe_bo_create_flags(fd, _vm,
> > bo_size,
> > - vram_memory(fd, eci->gt_id) |
> > + visible_vram_memory(fd, eci->gt_id) |
> > system_memory(fd));
> > }
> > } else {
> > @@ -449,9 +453,15 @@ threads(int fd, struct drm_xe_engine_class_instance *eci,
> > pthread_join(threads_data[i].thread, NULL);
> > }
> >
> > +#define SZ_256M 0x10000000
> > +#define SZ_1G 0x40000000
> > +
> > static uint64_t calc_bo_size(uint64_t vram_size, int mul, int div)
> > {
> > - return (ALIGN(vram_size, 0x40000000) * mul) / div;
> > + if (vram_size >= SZ_1G)
> > + return (ALIGN(vram_size, SZ_1G) * mul) / div;
> > + else
> > + return (ALIGN(vram_size, SZ_256M) * mul) / div; /* small-bar */
> > }
> >
> > /**
> > @@ -664,7 +674,7 @@ igt_main
> > igt_fixture {
> > fd = drm_open_driver(DRIVER_XE);
> > igt_require(xe_has_vram(fd));
> > - vram_size = xe_vram_size(fd, 0);
> > + vram_size = xe_visible_vram_size(fd, 0);
> > igt_assert(vram_size);
> >
> > xe_for_each_hw_engine(fd, hwe)
> > diff --git a/tests/xe/xe_exec_balancer.c b/tests/xe/xe_exec_balancer.c
> > index 8df6ceba8..0b00d93de 100644
> > --- a/tests/xe/xe_exec_balancer.c
> > +++ b/tests/xe/xe_exec_balancer.c
> > @@ -69,7 +69,7 @@ static void test_all_active(int fd, int gt, int class)
> > bo_size = sizeof(*data) * num_placements;
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd), xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, gt, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > for (i = 0; i < num_placements; i++) {
> > @@ -225,7 +225,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
> > }
> > memset(data, 0, bo_size);
> > } else {
> > - bo = xe_bo_create(fd, gt, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> >
> > @@ -447,7 +447,7 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
> > igt_assert(data);
> > }
> > } else {
> > - bo = xe_bo_create(fd, gt, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(data, 0, bo_size);
> > diff --git a/tests/xe/xe_exec_basic.c b/tests/xe/xe_exec_basic.c
> > index af581c327..a4bae93f0 100644
> > --- a/tests/xe/xe_exec_basic.c
> > +++ b/tests/xe/xe_exec_basic.c
> > @@ -126,15 +126,14 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
> > }
> > memset(data, 0, bo_size);
> > } else {
> > - if (flags & DEFER_ALLOC) {
> > - bo = xe_bo_create_flags(fd, n_vm == 1 ? vm[0] : 0,
> > - bo_size,
> > - vram_if_possible(fd, eci->gt_id) |
> > - XE_GEM_CREATE_FLAG_DEFER_BACKING);
> > - } else {
> > - bo = xe_bo_create(fd, eci->gt_id, n_vm == 1 ? vm[0] : 0,
> > - bo_size);
> > - }
> > + uint32_t bo_flags;
> > +
> > + bo_flags = visible_vram_if_possible(fd, eci->gt_id);
> > + if (flags & DEFER_ALLOC)
> > + bo_flags |= XE_GEM_CREATE_FLAG_DEFER_BACKING;
> > +
> > + bo = xe_bo_create_flags(fd, n_vm == 1 ? vm[0] : 0,
> > + bo_size, bo_flags);
> > if (!(flags & DEFER_BIND))
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > diff --git a/tests/xe/xe_exec_compute_mode.c b/tests/xe/xe_exec_compute_mode.c
> > index 27b538414..ee9756c21 100644
> > --- a/tests/xe/xe_exec_compute_mode.c
> > +++ b/tests/xe/xe_exec_compute_mode.c
> > @@ -150,8 +150,8 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
> > igt_assert(data);
> > }
> > } else {
> > - bo = xe_bo_create(fd, eci->gt_id, flags & VM_FOR_BO ? vm : 0,
> > - bo_size);
> > + bo = xe_bo_create_flags(fd, flags & VM_FOR_BO ? vm : 0,
> > + bo_size, visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(data, 0, bo_size);
> > diff --git a/tests/xe/xe_exec_fault_mode.c b/tests/xe/xe_exec_fault_mode.c
> > index bf7230c5a..7dcbb3c45 100644
> > --- a/tests/xe/xe_exec_fault_mode.c
> > +++ b/tests/xe/xe_exec_fault_mode.c
> > @@ -153,9 +153,11 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
> > } else {
> > if (flags & PREFETCH)
> > bo = xe_bo_create_flags(fd, 0, bo_size,
> > - all_memory_regions(fd));
> > + all_memory_regions(fd) |
> > + visible_vram_if_possible(fd, 0));
> > else
> > - bo = xe_bo_create(fd, eci->gt_id, 0, bo_size);
> > + bo = xe_bo_create_flags(fd, 0, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(data, 0, bo_size);
> > @@ -382,8 +384,10 @@ test_atomic(int fd, struct drm_xe_engine_class_instance *eci,
> > addr_wait = addr + bo_size;
> >
> > bo = xe_bo_create_flags(fd, vm, bo_size,
> > - all_memory_regions(fd));
> > - bo_wait = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + all_memory_regions(fd) |
> > + visible_vram_if_possible(fd, 0));
> > + bo_wait = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> > wait = xe_bo_map(fd, bo_wait, bo_size);
> > ptr = &data[0].data;
> > diff --git a/tests/xe/xe_exec_reset.c b/tests/xe/xe_exec_reset.c
> > index 6ca1cd769..dfbaa6035 100644
> > --- a/tests/xe/xe_exec_reset.c
> > +++ b/tests/xe/xe_exec_reset.c
> > @@ -50,7 +50,8 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > spin = xe_bo_map(fd, bo, bo_size);
> >
> > engine = xe_engine_create(fd, vm, eci, 0);
> > @@ -187,7 +188,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, gt, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > for (i = 0; i < n_engines; i++) {
> > @@ -379,7 +380,8 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > for (i = 0; i < n_engines; i++) {
> > @@ -550,7 +552,8 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> > memset(data, 0, bo_size);
> >
> > @@ -682,7 +685,7 @@ static void submit_jobs(struct gt_thread_data *t)
> > uint32_t bo;
> > uint32_t *data;
> >
> > - bo = xe_bo_create(fd, 0, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, 0));
> > data = xe_bo_map(fd, bo, bo_size);
> > data[0] = MI_BATCH_BUFFER_END;
> >
> > diff --git a/tests/xe/xe_exec_store.c b/tests/xe/xe_exec_store.c
> > index 9640b1567..ab1bde36e 100644
> > --- a/tests/xe/xe_exec_store.c
> > +++ b/tests/xe/xe_exec_store.c
> > @@ -82,7 +82,8 @@ static void store(int fd)
> > xe_get_default_alignment(fd));
> >
> > hw_engine = xe_hw_engine(fd, 1);
> > - bo = xe_bo_create(fd, hw_engine->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, hw_engine->gt_id));
> >
> > xe_vm_bind_async(fd, vm, hw_engine->gt_id, bo, 0, addr, bo_size, &sync, 1);
> > data = xe_bo_map(fd, bo, bo_size);
> > @@ -138,7 +139,8 @@ static void store_all(int fd, int gt, int class)
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, 0, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, 0));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > xe_for_each_hw_engine(fd, hwe) {
> > diff --git a/tests/xe/xe_exec_threads.c b/tests/xe/xe_exec_threads.c
> > index 414d8ee9a..396398984 100644
> > --- a/tests/xe/xe_exec_threads.c
> > +++ b/tests/xe/xe_exec_threads.c
> > @@ -106,7 +106,8 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
> > igt_assert(data);
> > }
> > } else {
> > - bo = xe_bo_create(fd, gt, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, gt));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(data, 0, bo_size);
> > @@ -306,7 +307,8 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
> > igt_assert(data);
> > }
> > } else {
> > - bo = xe_bo_create(fd, eci->gt_id, 0, bo_size);
> > + bo = xe_bo_create_flags(fd, 0, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(data, 0, bo_size);
> > @@ -516,7 +518,8 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
> > igt_assert(data);
> > }
> > } else {
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(data, 0, bo_size);
> > diff --git a/tests/xe/xe_guc_pc.c b/tests/xe/xe_guc_pc.c
> > index c34df8d60..6339b3893 100644
> > --- a/tests/xe/xe_guc_pc.c
> > +++ b/tests/xe/xe_guc_pc.c
> > @@ -64,7 +64,8 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > for (i = 0; i < n_engines; i++) {
> > diff --git a/tests/xe/xe_mmap.c b/tests/xe/xe_mmap.c
> > index 798facca9..583f39d7a 100644
> > --- a/tests/xe/xe_mmap.c
> > +++ b/tests/xe/xe_mmap.c
> > @@ -118,10 +118,10 @@ igt_main
> > test_mmap(fd, system_memory(fd));
> >
> > igt_subtest("vram")
> > - test_mmap(fd, vram_memory(fd, 0));
> > + test_mmap(fd, visible_vram_memory(fd, 0));
> >
> > igt_subtest("vram-system")
> > - test_mmap(fd, vram_memory(fd, 0) | system_memory(fd));
> > + test_mmap(fd, visible_vram_memory(fd, 0) | system_memory(fd));
> >
> > igt_subtest("bad-flags")
> > test_bad_flags(fd);
> > diff --git a/tests/xe/xe_pm.c b/tests/xe/xe_pm.c
> > index a7f73c4e6..559eccdeb 100644
> > --- a/tests/xe/xe_pm.c
> > +++ b/tests/xe/xe_pm.c
> > @@ -254,7 +254,8 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
> > if (check_rpm && runtime_usage_available(device.pci_xe))
> > rpm_usage = igt_pm_get_runtime_usage(device.pci_xe);
> >
> > - bo = xe_bo_create(device.fd_xe, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(device.fd_xe, vm, bo_size,
> > + visible_vram_if_possible(device.fd_xe, eci->gt_id));
> > data = xe_bo_map(device.fd_xe, bo, bo_size);
> >
> > for (i = 0; i < n_engines; i++) {
> > diff --git a/tests/xe/xe_prime_self_import.c b/tests/xe/xe_prime_self_import.c
> > index 0fd79f704..e712e2a9c 100644
> > --- a/tests/xe/xe_prime_self_import.c
> > +++ b/tests/xe/xe_prime_self_import.c
> > @@ -107,7 +107,7 @@ static void test_with_fd_dup(void)
> > fd1 = drm_open_driver(DRIVER_XE);
> > fd2 = drm_open_driver(DRIVER_XE);
> >
> > - handle = xe_bo_create(fd1, 0, 0, BO_SIZE);
> > + handle = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
> >
> > dma_buf_fd1 = prime_handle_to_fd(fd1, handle);
> > gem_close(fd1, handle);
> > @@ -141,8 +141,8 @@ static void test_with_two_bos(void)
> > fd1 = drm_open_driver(DRIVER_XE);
> > fd2 = drm_open_driver(DRIVER_XE);
> >
> > - handle1 = xe_bo_create(fd1, 0, 0, BO_SIZE);
> > - handle2 = xe_bo_create(fd1, 0, 0, BO_SIZE);
> > + handle1 = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
> > + handle2 = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
> >
> > dma_buf_fd = prime_handle_to_fd(fd1, handle1);
> > handle_import = prime_fd_to_handle(fd2, dma_buf_fd);
> > @@ -211,7 +211,7 @@ static void test_with_one_bo(void)
> > fd1 = drm_open_driver(DRIVER_XE);
> > fd2 = drm_open_driver(DRIVER_XE);
> >
> > - handle = xe_bo_create(fd1, 0, 0, BO_SIZE);
> > + handle = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
> >
> > dma_buf_fd = prime_handle_to_fd(fd1, handle);
> > handle_import1 = prime_fd_to_handle(fd2, dma_buf_fd);
> > diff --git a/tests/xe/xe_vm.c b/tests/xe/xe_vm.c
> > index 04d6c3956..982c50f6d 100644
> > --- a/tests/xe/xe_vm.c
> > +++ b/tests/xe/xe_vm.c
> > @@ -52,7 +52,8 @@ write_dwords(int fd, uint32_t vm, int n_dwords, uint64_t *addrs)
> > batch_size = (n_dwords * 4 + 1) * sizeof(uint32_t);
> > batch_size = ALIGN(batch_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> > - batch_bo = xe_bo_create(fd, 0, vm, batch_size);
> > + batch_bo = xe_bo_create_flags(fd, vm, batch_size,
> > + visible_vram_if_possible(fd, 0));
> > batch_map = xe_bo_map(fd, batch_bo, batch_size);
> >
> > for (i = 0; i < n_dwords; i++) {
> > @@ -116,7 +117,7 @@ __test_bind_one_bo(int fd, uint32_t vm, int n_addrs, uint64_t *addrs)
> > vms = malloc(sizeof(*vms) * n_addrs);
> > igt_assert(vms);
> > }
> > - bo = xe_bo_create(fd, 0, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, 0));
> > map = xe_bo_map(fd, bo, bo_size);
> > memset(map, 0, bo_size);
> >
> > @@ -554,7 +555,8 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
> > xe_get_default_alignment(fd));
> >
> > for (i = 0; i < n_bo; ++i) {
> > - bo[i] = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo[i] = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data[i] = xe_bo_map(fd, bo[i], bo_size);
> > }
> >
> > @@ -723,7 +725,8 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci)
> > bo_size = sizeof(*data) * N_ENGINES;
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > for (i = 0; i < N_ENGINES; i++) {
> > @@ -880,7 +883,8 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
> > bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> > xe_get_default_alignment(fd));
> >
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > data = xe_bo_map(fd, bo, bo_size);
> >
> > if (flags & BIND_ARRAY_BIND_ENGINE_FLAG)
> > @@ -1072,7 +1076,11 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
> > map = aligned_alloc(xe_get_default_alignment(fd), bo_size);
> > igt_assert(map);
> > } else {
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + igt_skip_on(xe_visible_vram_size(fd, 0) && bo_size >
> > + xe_visible_vram_size(fd, 0));
>
>
> redundant 'xe_visible_vram_size(fd, 0)' if it is 0 it will be smaller than bo_size.
miss read this, please ignore the comment above.
>
> Other than this and the missing cases LGTM.
>
> > +
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > map = xe_bo_map(fd, bo, bo_size);
> > }
> >
> > @@ -1350,7 +1358,8 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
> > MAP_ANONYMOUS, -1, 0);
> > igt_assert(map != MAP_FAILED);
> > } else {
> > - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> > + bo = xe_bo_create_flags(fd, vm, bo_size,
> > + visible_vram_if_possible(fd, eci->gt_id));
> > map = xe_bo_map(fd, bo, bo_size);
> > }
> > memset(map, 0, bo_size);
>
More information about the igt-dev
mailing list